var __reflect = (this && this.__reflect) || function (p, c, t) {
  p.__class__ = c, t ? t.push(c) : t = [c], p.__types__ = p.__types__ ? t.concat(p.__types__) : t;
};
var __extends = this && this.__extends || function __extends(t, e) { 
function r() { 
this.constructor = t;
}
for (var i in e) e.hasOwnProperty(i) && (t[i] = e[i]);
r.prototype = e.prototype, t.prototype = new r();
};
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebFps = (function (_super) {
          __extends(WebFps, _super);
          function WebFps(stage, showFPS, showLog, logFilter, styles) {
              var _this = _super.call(this) || this;
              _this.showPanle = true;
              _this.fpsHeight = 0;
              _this.WIDTH = 101;
              _this.HEIGHT = 20;
              _this.bgCanvasColor = "#18304b";
              _this.fpsFrontColor = "#18fefe";
              _this.WIDTH_COST = 50;
              _this.cost1Color = "#18fefe";
              // private cost2Color = "#ffff00";
              _this.cost3Color = "#ff0000";
              _this.arrFps = [];
              _this.arrCost = [];
              _this.arrLog = [];
              if (showFPS || showLog) {
                  if (egret.Capabilities.renderMode == 'canvas') {
                      _this.renderMode = "Canvas";
                  }
                  else {
                      _this.renderMode = "WebGL";
                  }
                  _this.panelX = styles["x"] === undefined ? 0 : parseInt(styles['x']);
                  _this.panelY = styles["y"] === undefined ? 0 : parseInt(styles['y']);
                  _this.fontColor = styles["textColor"] === undefined ? '#ffffff' : styles['textColor'].replace("0x", "#");
                  _this.fontSize = styles["size"] === undefined ? 12 : parseInt(styles['size']);
                  if (egret.Capabilities.isMobile) {
                      _this.fontSize -= 2;
                  }
                  var all = document.createElement('div');
                  all.style.position = 'absolute';
                  all.style.background = "rgba(0,0,0," + styles['bgAlpha'] + ")";
                  all.style.left = _this.panelX + 'px';
                  all.style.top = _this.panelY + 'px';
                  all.style.pointerEvents = 'none';
                  document.body.appendChild(all);
                  var container = document.createElement('div');
                  container.style.color = _this.fontColor;
                  container.style.fontSize = _this.fontSize + 'px';
                  container.style.lineHeight = _this.fontSize + 'px';
                  container.style.margin = '4px 4px 4px 4px';
                  _this.container = container;
                  all.appendChild(container);
                  if (showFPS)
                      _this.addFps();
                  if (showLog)
                      _this.addLog();
              }
              return _this;
          }
          WebFps.prototype.addFps = function () {
              var div = document.createElement('div');
              div.style.display = 'inline-block';
              this.containerFps = div;
              this.container.appendChild(div);
              var fps = document.createElement('div');
              fps.style.paddingBottom = '2px';
              this.fps = fps;
              this.containerFps.appendChild(fps);
              fps.innerHTML = "0 FPS " + this.renderMode + "<br/>min0 max0 avg0";
              var canvas = document.createElement('canvas');
              this.containerFps.appendChild(canvas);
              canvas.width = this.WIDTH;
              canvas.height = this.HEIGHT;
              this.canvasFps = canvas;
              var context = canvas.getContext('2d');
              this.contextFps = context;
              context.fillStyle = this.bgCanvasColor;
              context.fillRect(0, 0, this.WIDTH, this.HEIGHT);
              var divDatas = document.createElement('div');
              this.divDatas = divDatas;
              this.containerFps.appendChild(divDatas);
              var left = document.createElement('div');
              left.style['float'] = 'left';
              left.innerHTML = "Draw<br/>Cost";
              divDatas.appendChild(left);
              var right = document.createElement('div');
              right.style.paddingLeft = left.offsetWidth + 20 + "px";
              divDatas.appendChild(right);
              var draw = document.createElement('div');
              this.divDraw = draw;
              draw.innerHTML = "0<br/>";
              right.appendChild(draw);
              var cost = document.createElement('div');
              this.divCost = cost;
              cost.innerHTML = "<font  style=\"color:" + this.cost1Color + "\">0<font/> <font  style=\"color:" + this.cost3Color + "\">0<font/>";
              right.appendChild(cost);
              canvas = document.createElement('canvas');
              this.canvasCost = canvas;
              this.containerFps.appendChild(canvas);
              canvas.width = this.WIDTH;
              canvas.height = this.HEIGHT;
              context = canvas.getContext('2d');
              this.contextCost = context;
              context.fillStyle = this.bgCanvasColor;
              context.fillRect(0, 0, this.WIDTH, this.HEIGHT);
              context.fillStyle = "#000000";
              context.fillRect(this.WIDTH_COST, 0, 1, this.HEIGHT);
              this.fpsHeight = this.container.offsetHeight;
          };
          WebFps.prototype.addLog = function () {
              var log = document.createElement('div');
              log.style.maxWidth = document.body.clientWidth - 8 - this.panelX + 'px';
              log.style.wordWrap = "break-word";
              this.log = log;
              this.container.appendChild(log);
          };
          WebFps.prototype.update = function (datas, showLastData) {
              if (showLastData === void 0) { showLastData = false; }
              var numFps;
              var numCostTicker;
              var numCostRender;
              if (!showLastData) {
                  numFps = datas.fps;
                  numCostTicker = datas.costTicker;
                  numCostRender = datas.costRender;
                  this.lastNumDraw = datas.draw;
                  this.arrFps.push(numFps);
                  this.arrCost.push([numCostTicker, numCostRender]);
              }
              else {
                  numFps = this.arrFps[this.arrFps.length - 1];
                  numCostTicker = this.arrCost[this.arrCost.length - 1][0];
                  numCostRender = this.arrCost[this.arrCost.length - 1][1];
              }
              var fpsTotal = 0;
              var lenFps = this.arrFps.length;
              if (lenFps > 101) {
                  lenFps = 101;
                  this.arrFps.shift();
                  this.arrCost.shift();
              }
              var fpsMin = this.arrFps[0];
              var fpsMax = this.arrFps[0];
              for (var i = 0; i < lenFps; i++) {
                  var num = this.arrFps[i];
                  fpsTotal += num;
                  if (num < fpsMin)
                      fpsMin = num;
                  else if (num > fpsMax)
                      fpsMax = num;
              }
              var WIDTH = this.WIDTH;
              var HEIGHT = this.HEIGHT;
              var context = this.contextFps;
              context.drawImage(this.canvasFps, 1, 0, WIDTH - 1, HEIGHT, 0, 0, WIDTH - 1, HEIGHT);
              context.fillStyle = this.bgCanvasColor;
              context.fillRect(WIDTH - 1, 0, 1, HEIGHT);
              var lastHeight = Math.floor(numFps / 60 * 20);
              if (lastHeight < 1)
                  lastHeight = 1;
              context.fillStyle = this.fpsFrontColor;
              context.fillRect(WIDTH - 1, 20 - lastHeight, 1, lastHeight);
              var WIDTH_COST = this.WIDTH_COST;
              context = this.contextCost;
              context.drawImage(this.canvasCost, 1, 0, WIDTH_COST - 1, HEIGHT, 0, 0, WIDTH_COST - 1, HEIGHT);
              context.drawImage(this.canvasCost, WIDTH_COST + 2, 0, WIDTH_COST - 1, HEIGHT, WIDTH_COST + 1, 0, WIDTH_COST - 1, HEIGHT);
              var c1Height = Math.floor(numCostTicker / 2);
              if (c1Height < 1)
                  c1Height = 1;
              else if (c1Height > 20)
                  c1Height = 20;
              //todo lcj
              var c2Height = Math.floor(numCostRender / 2);
              if (c2Height < 1)
                  c2Height = 1;
              else if (c2Height > 20)
                  c2Height = 20;
              context.fillStyle = this.bgCanvasColor;
              context.fillRect(WIDTH_COST - 1, 0, 1, HEIGHT);
              context.fillRect(WIDTH_COST * 2, 0, 1, HEIGHT);
              context.fillRect(WIDTH_COST * 3 + 1, 0, 1, HEIGHT);
              context.fillStyle = this.cost1Color;
              context.fillRect(WIDTH_COST - 1, 20 - c1Height, 1, c1Height);
              context.fillStyle = this.cost3Color;
              context.fillRect(WIDTH_COST * 2, 20 - c2Height, 1, c2Height);
              var fpsAvg = Math.floor(fpsTotal / lenFps);
              var fpsOutput = numFps + " FPS " + this.renderMode;
              if (this.showPanle) {
                  fpsOutput += "<br/>min" + fpsMin + " max" + fpsMax + " avg" + fpsAvg;
                  this.divDraw.innerHTML = this.lastNumDraw + "<br/>";
                  this.divCost.innerHTML = "<font  style=\"color:#18fefe\">" + numCostTicker + "<font/> <font  style=\"color:#ff0000\">" + numCostRender + "<font/>";
              }
              this.fps.innerHTML = fpsOutput;
          };
          ;
          WebFps.prototype.updateInfo = function (info) {
              this.arrLog.push(info);
              this.log.innerHTML = this.arrLog.join('<br/>');
              while (document.body.clientHeight < (this.log.offsetHeight + this.fpsHeight + this.panelY + this.fontSize * 2)) {
                  this.arrLog.shift();
                  this.log.innerHTML = this.arrLog.join('<br/>');
              }
          };
          WebFps.prototype.updateWarn = function (info) {
          };
          WebFps.prototype.updateError = function (info) {
          };
          return WebFps;
      }(egret.DisplayObject));
      wxgame.WebFps = WebFps;
      __reflect(WebFps.prototype, "egret.wxgame.WebFps", ["egret.FPSDisplay"]);
      egret.FPSDisplay = WebFps;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////
if (window['HTMLDivElement'] == undefined) {
  window['HTMLDivElement'] = HTMLElement;
}
// There is no HTMLDivElement in webkit for air
if (window['HTMLVideoElement'] == undefined) {
  window['HTMLVideoElement'] = HTMLDivElement;
}

(function (egret) {
  var wxgame;
  (function (wxgame) {
      var className = "egret.BitmapData";
      egret.registerClass(HTMLImageElement, className);
      egret.registerClass(HTMLCanvasElement, className);
      egret.registerClass(HTMLVideoElement, className);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
(function (egret) {
  /**
   * 转换 Image，Canvas，Video 为 Egret 框架内使用的 BitmapData 对象。
   * @param data 需要转换的对象，包括HTMLImageElement|HTMLCanvasElement|HTMLVideoElement
   * @deprecated
   */
  function $toBitmapData(data) {
      data["hashCode"] = data["$hashCode"] = egret.$hashCount++;
      return data;
  }
  egret.$toBitmapData = $toBitmapData;
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var localStorage;
  (function (localStorage) {
      var wxgame;
      (function (wxgame) {
          /**
           * @private
           *
           * @param key
           * @returns
           */
          function getItem(key) {
              return window.localStorage.getItem(key);
          }
          /**
           * @private
           *
           * @param key
           * @param value
           * @returns
           */
          function setItem(key, value) {
              try {
                  window.localStorage.setItem(key, value);
                  return true;
              }
              catch (e) {
                  egret.$warn(1047, key, value);
                  return false;
              }
          }
          /**
           * @private
           *
           * @param key
           */
          function removeItem(key) {
              window.localStorage.removeItem(key);
          }
          /**
           * @private
           *
           */
          function clear() {
              window.localStorage.clear();
          }
          localStorage.getItem = getItem;
          localStorage.setItem = setItem;
          localStorage.removeItem = removeItem;
          localStorage.clear = clear;
      })(wxgame = localStorage.wxgame || (localStorage.wxgame = {}));
  })(localStorage = egret.localStorage || (egret.localStorage = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * @inheritDoc
       */
      var HtmlSound = (function (_super) {
          __extends(HtmlSound, _super);
          /**
           * @private
           * @inheritDoc
           */
          function HtmlSound() {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.loaded = false;
              return _this;
          }
          Object.defineProperty(HtmlSound.prototype, "length", {
              get: function () {
                  if (this.originAudio) {
                      return this.originAudio.duration;
                  }
                  throw new Error("sound not loaded!");
                  //return 0;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * @inheritDoc
           */
          HtmlSound.prototype.load = function (url) {
              var self = this;
              this.url = url;
              if (true && !url) {
                  egret.$error(3002);
              }
              var audio = new Audio(url);
              audio.addEventListener("canplaythrough", onAudioLoaded);
              audio.addEventListener("error", onAudioError);
              var ua = navigator.userAgent.toLowerCase();
              if (ua.indexOf("firefox") >= 0) {
                  audio.autoplay = !0;
                  audio.muted = true;
              }
              // audio.load();     wxgame没有此接口
              this.originAudio = audio;
              if (HtmlSound.clearAudios[this.url]) {
                  delete HtmlSound.clearAudios[this.url];
              }
              HtmlSound.$recycle(this.url, audio);
              function onAudioLoaded() {
                  removeListeners();
                  if (ua.indexOf("firefox") >= 0) {
                      audio.pause();
                      audio.muted = false;
                  }
                  self.loaded = true;
                  self.dispatchEventWith(egret.Event.COMPLETE);
              }
              function onAudioError() {
                  removeListeners();
                  self.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
              }
              function removeListeners() {
                  audio.removeEventListener("canplaythrough", onAudioLoaded);
                  audio.removeEventListener("error", onAudioError);
              }
          };
          /**
           * @inheritDoc
           */
          HtmlSound.prototype.play = function (startTime, loops) {
              startTime = +startTime || 0;
              loops = +loops || 0;
              if (true && this.loaded == false) {
                  egret.$error(1049);
              }
              var audio = HtmlSound.$pop(this.url);
              if (audio == null) {
                  audio = this.originAudio.cloneNode();
              }
              else {
                  //audio.load();
              }
              audio.autoplay = true;
              var channel = new wxgame.HtmlSoundChannel(audio);
              channel.$url = this.url;
              channel.$loops = loops;
              channel.$startTime = startTime;
              channel.$play();
              egret.sys.$pushSoundChannel(channel);
              return channel;
          };
          /**
           * @inheritDoc
           */
          HtmlSound.prototype.close = function () {
              if (this.loaded == false && this.originAudio)
                  this.originAudio.src = "";
              if (this.originAudio)
                  this.originAudio = null;
              HtmlSound.$clear(this.url);
          };
          HtmlSound.$clear = function (url) {
              HtmlSound.clearAudios[url] = true;
              var array = HtmlSound.audios[url];
              if (array) {
                  array.length = 0;
              }
          };
          HtmlSound.$pop = function (url) {
              var array = HtmlSound.audios[url];
              if (array && array.length > 0) {
                  return array.pop();
              }
              return null;
          };
          HtmlSound.$recycle = function (url, audio) {
              if (HtmlSound.clearAudios[url]) {
                  return;
              }
              var array = HtmlSound.audios[url];
              if (HtmlSound.audios[url] == null) {
                  array = HtmlSound.audios[url] = [];
              }
              array.push(audio);
          };
          /**
           * Background music
           * @version Egret 2.4
           * @platform Web,Native
           * @language en_US
           */
          /**
           * 背景音乐
           * @version Egret 2.4
           * @platform Web,Native
           * @language zh_CN
           */
          HtmlSound.MUSIC = "music";
          /**
           * EFFECT
           * @version Egret 2.4
           * @platform Web,Native
           * @language en_US
           */
          /**
           * 音效
           * @version Egret 2.4
           * @platform Web,Native
           * @language zh_CN
           */
          HtmlSound.EFFECT = "effect";
          /**
           * @private
           */
          HtmlSound.audios = {};
          HtmlSound.clearAudios = {};
          return HtmlSound;
      }(egret.EventDispatcher));
      wxgame.HtmlSound = HtmlSound;
      __reflect(HtmlSound.prototype, "egret.wxgame.HtmlSound", ["egret.Sound"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * @inheritDoc
       */
      var HtmlSoundChannel = (function (_super) {
          __extends(HtmlSoundChannel, _super);
          /**
           * @private
           */
          function HtmlSoundChannel(audio) {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.$startTime = 0;
              /**
               * @private
               */
              _this.audio = null;
              //声音是否已经播放完成
              _this.isStopped = false;
              /**
               * @private
               */
              _this.onPlayEnd = function () {
                  if (_this.$loops == 1) {
                      _this.stop();
                      _this.dispatchEventWith(egret.Event.SOUND_COMPLETE);
                      return;
                  }
                  if (_this.$loops > 0) {
                      _this.$loops--;
                  }
                  /////////////
                  //this.audio.load();
                  _this.$play();
              };
              /**
               * @private
               */
              _this._volume = 1;
              audio.addEventListener("ended", _this.onPlayEnd);
              _this.audio = audio;
              return _this;
          }
          HtmlSoundChannel.prototype.$play = function () {
              if (this.isStopped) {
                  egret.$error(1036);
                  return;
              }
              this.audio.play();
              this.audio.volume = this._volume;
              this.audio.currentTime = this.$startTime;
          };
          /**
           * @private
           * @inheritDoc
           */
          HtmlSoundChannel.prototype.stop = function () {
              if (!this.audio)
                  return;
              if (!this.isStopped) {
                  egret.sys.$popSoundChannel(this);
              }
              this.isStopped = true;
              var audio = this.audio;
              audio.removeEventListener("ended", this.onPlayEnd);
              audio.volume = 0;
              this._volume = 0;
              this.audio = null;
              var url = this.$url;
              //延迟一定时间再停止，规避chrome报错
              window.setTimeout(function () {
                  audio.pause();
                  wxgame.HtmlSound.$recycle(url, audio);
              }, 200);
          };
          Object.defineProperty(HtmlSoundChannel.prototype, "volume", {
              /**
               * @private
               * @inheritDoc
               */
              get: function () {
                  return this._volume;
              },
              /**
               * @inheritDoc
               */
              set: function (value) {
                  if (this.isStopped) {
                      egret.$error(1036);
                      return;
                  }
                  this._volume = value;
                  if (!this.audio)
                      return;
                  this.audio.volume = value;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(HtmlSoundChannel.prototype, "position", {
              /**
               * @private
               * @inheritDoc
               */
              get: function () {
                  if (!this.audio)
                      return 0;
                  return this.audio.currentTime;
              },
              enumerable: true,
              configurable: true
          });
          return HtmlSoundChannel;
      }(egret.EventDispatcher));
      wxgame.HtmlSoundChannel = HtmlSoundChannel;
      __reflect(HtmlSoundChannel.prototype, "egret.wxgame.HtmlSoundChannel", ["egret.SoundChannel", "egret.IEventDispatcher"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebAudioDecode = (function () {
          function WebAudioDecode() {
          }
          /**
           * @private
           *
           */
          WebAudioDecode.decodeAudios = function () {
              if (WebAudioDecode.decodeArr.length <= 0) {
                  return;
              }
              if (WebAudioDecode.isDecoding) {
                  return;
              }
              WebAudioDecode.isDecoding = true;
              var decodeInfo = WebAudioDecode.decodeArr.shift();
              WebAudioDecode.ctx.decodeAudioData(decodeInfo["buffer"], function (audioBuffer) {
                  decodeInfo["self"].audioBuffer = audioBuffer;
                  if (decodeInfo["success"]) {
                      decodeInfo["success"]();
                  }
                  WebAudioDecode.isDecoding = false;
                  WebAudioDecode.decodeAudios();
              }, function () {
                  alert("sound decode error: " + decodeInfo["url"] + "！\nsee http://edn.egret.com/cn/docs/page/156");
                  if (decodeInfo["fail"]) {
                      decodeInfo["fail"]();
                  }
                  WebAudioDecode.isDecoding = false;
                  WebAudioDecode.decodeAudios();
              });
          };
          /**
           * @private
           */
          WebAudioDecode.decodeArr = [];
          /**
           * @private
           */
          WebAudioDecode.isDecoding = false;
          return WebAudioDecode;
      }());
      wxgame.WebAudioDecode = WebAudioDecode;
      __reflect(WebAudioDecode.prototype, "egret.wxgame.WebAudioDecode");
      /**
       * @private
       * @inheritDoc
       */
      var WebAudioSound = (function (_super) {
          __extends(WebAudioSound, _super);
          /**
           * @private
           * @inheritDoc
           */
          function WebAudioSound() {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.loaded = false;
              return _this;
          }
          Object.defineProperty(WebAudioSound.prototype, "length", {
              get: function () {
                  if (this.audioBuffer) {
                      return this.audioBuffer.duration;
                  }
                  throw new Error("sound not loaded!");
                  //return 0;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * @inheritDoc
           */
          WebAudioSound.prototype.load = function (url) {
              var self = this;
              this.url = url;
              if (true && !url) {
                  egret.$error(3002);
              }
              var request = new XMLHttpRequest();
              request.open("GET", url, true);
              request.responseType = "arraybuffer";
              request.onreadystatechange = function () {
                  if (request.readyState == 4) {
                      var ioError = (request.status >= 400 || request.status == 0);
                      if (ioError) {
                          self.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
                      }
                      else {
                          WebAudioDecode.decodeArr.push({
                              "buffer": request.response,
                              "success": onAudioLoaded,
                              "fail": onAudioError,
                              "self": self,
                              "url": self.url
                          });
                          WebAudioDecode.decodeAudios();
                      }
                  }
              };
              request.send();
              function onAudioLoaded() {
                  self.loaded = true;
                  self.dispatchEventWith(egret.Event.COMPLETE);
              }
              function onAudioError() {
                  self.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
              }
          };
          /**
           * @inheritDoc
           */
          WebAudioSound.prototype.play = function (startTime, loops) {
              startTime = +startTime || 0;
              loops = +loops || 0;
              if (true && this.loaded == false) {
                  egret.$error(1049);
              }
              var channel = new wxgame.WebAudioSoundChannel();
              channel.$url = this.url;
              channel.$loops = loops;
              channel.$audioBuffer = this.audioBuffer;
              channel.$startTime = startTime;
              channel.$play();
              egret.sys.$pushSoundChannel(channel);
              return channel;
          };
          /**
           * @inheritDoc
           */
          WebAudioSound.prototype.close = function () {
          };
          /**
           * Background music
           * @version Egret 2.4
           * @platform Web,Native
           * @language en_US
           */
          /**
           * 背景音乐
           * @version Egret 2.4
           * @platform Web,Native
           * @language zh_CN
           */
          WebAudioSound.MUSIC = "music";
          /**
           * EFFECT
           * @version Egret 2.4
           * @platform Web,Native
           * @language en_US
           */
          /**
           * 音效
           * @version Egret 2.4
           * @platform Web,Native
           * @language zh_CN
           */
          WebAudioSound.EFFECT = "effect";
          return WebAudioSound;
      }(egret.EventDispatcher));
      wxgame.WebAudioSound = WebAudioSound;
      __reflect(WebAudioSound.prototype, "egret.wxgame.WebAudioSound", ["egret.Sound"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * @inheritDoc
       */
      var WebAudioSoundChannel = (function (_super) {
          __extends(WebAudioSoundChannel, _super);
          /**
           * @private
           */
          function WebAudioSoundChannel() {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.$startTime = 0;
              /**
               * @private
               */
              _this.bufferSource = null;
              /**
               * @private
               */
              _this.context = wxgame.WebAudioDecode.ctx;
              //声音是否已经播放完成
              _this.isStopped = false;
              /**
               * @private
               */
              _this._currentTime = 0;
              /**
               * @private
               */
              _this._volume = 1;
              /**
               * @private
               */
              _this.onPlayEnd = function () {
                  if (_this.$loops == 1) {
                      _this.stop();
                      _this.dispatchEventWith(egret.Event.SOUND_COMPLETE);
                      return;
                  }
                  if (_this.$loops > 0) {
                      _this.$loops--;
                  }
                  /////////////
                  _this.$play();
              };
              /**
               * @private
               */
              _this._startTime = 0;
              if (_this.context["createGain"]) {
                  _this.gain = _this.context["createGain"]();
              }
              else {
                  _this.gain = _this.context["createGainNode"]();
              }
              return _this;
          }
          WebAudioSoundChannel.prototype.$play = function () {
              if (this.isStopped) {
                  egret.$error(1036);
                  return;
              }
              if (this.bufferSource) {
                  this.bufferSource.onended = null;
                  this.bufferSource = null;
              }
              var context = this.context;
              var gain = this.gain;
              var bufferSource = context.createBufferSource();
              this.bufferSource = bufferSource;
              bufferSource.buffer = this.$audioBuffer;
              bufferSource.connect(gain);
              gain.connect(context.destination);
              bufferSource.onended = this.onPlayEnd;
              this._startTime = Date.now();
              this.gain.gain.value = this._volume;
              bufferSource.start(0, this.$startTime);
              this._currentTime = 0;
          };
          WebAudioSoundChannel.prototype.stop = function () {
              if (this.bufferSource) {
                  var sourceNode = this.bufferSource;
                  if (sourceNode.stop) {
                      sourceNode.stop(0);
                  }
                  else {
                      sourceNode.noteOff(0);
                  }
                  sourceNode.onended = null;
                  sourceNode.disconnect();
                  this.bufferSource = null;
                  this.$audioBuffer = null;
              }
              if (!this.isStopped) {
                  egret.sys.$popSoundChannel(this);
              }
              this.isStopped = true;
          };
          Object.defineProperty(WebAudioSoundChannel.prototype, "volume", {
              /**
               * @private
               * @inheritDoc
               */
              get: function () {
                  return this._volume;
              },
              /**
               * @inheritDoc
               */
              set: function (value) {
                  if (this.isStopped) {
                      egret.$error(1036);
                      return;
                  }
                  this._volume = value;
                  this.gain.gain.value = value;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebAudioSoundChannel.prototype, "position", {
              /**
               * @private
               * @inheritDoc
               */
              get: function () {
                  if (this.bufferSource) {
                      return (Date.now() - this._startTime) / 1000 + this.$startTime;
                  }
                  return 0;
              },
              enumerable: true,
              configurable: true
          });
          return WebAudioSoundChannel;
      }(egret.EventDispatcher));
      wxgame.WebAudioSoundChannel = WebAudioSoundChannel;
      __reflect(WebAudioSoundChannel.prototype, "egret.wxgame.WebAudioSoundChannel", ["egret.SoundChannel", "egret.IEventDispatcher"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * @inheritDoc
       */
      var WebVideo = (function (_super) {
          __extends(WebVideo, _super);
          /**
           * @inheritDoc
           */
          function WebVideo(url, cache) {
              if (cache === void 0) { cache = true; }
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.loaded = false;
              /**
               * @private
               */
              _this.closed = false;
              /**
               * @private
               */
              _this.heightSet = NaN;
              /**
               * @private
               */
              _this.widthSet = NaN;
              /**
               * @private
               * pc上视频卡住的时候不能暂停
               */
              _this.waiting = false;
              /**
               * @private
               * 用户是否设置了 pause
               */
              _this.userPause = false;
              /**
               * @private
               * 用户是否设置了 play
               */
              _this.userPlay = false;
              _this.isPlayed = false;
              _this.screenChanged = function (e) {
                  var isfullscreen = document.fullscreenEnabled || document.webkitIsFullScreen;
                  if (!isfullscreen) {
                      _this.checkFullScreen(false);
                      if (!egret.Capabilities.isMobile) {
                          _this._fullscreen = isfullscreen;
                      }
                  }
              };
              _this._fullscreen = true;
              /**
               * @private
               *
               */
              _this.onVideoLoaded = function () {
                  _this.video.removeEventListener("canplay", _this.onVideoLoaded);
                  var video = _this.video;
                  _this.loaded = true;
                  //video.pause();
                  if (_this.posterData) {
                      _this.posterData.width = _this.getPlayWidth();
                      _this.posterData.height = _this.getPlayHeight();
                  }
                  video.width = video.videoWidth;
                  video.height = video.videoHeight;
                  window.setTimeout(function () {
                      _this.dispatchEventWith(egret.Event.COMPLETE);
                  }, 200);
              };
              _this.$renderNode = new egret.sys.BitmapNode();
              _this.src = url;
              _this.once(egret.Event.ADDED_TO_STAGE, _this.loadPoster, _this);
              if (url) {
                  _this.load();
              }
              return _this;
          }
          /**
           * @inheritDoc
           */
          WebVideo.prototype.load = function (url, cache) {
              var _this = this;
              if (cache === void 0) { cache = true; }
              url = url || this.src;
              this.src = url;
              if (true && !url) {
                  egret.$error(3002);
              }
              if (this.video && this.video.src == url) {
                  return;
              }
              var video;
              if (!this.video || egret.Capabilities.isMobile) {
                  video = document.createElement("video");
                  this.video = video;
                  video.controls = null;
              }
              else {
                  video = this.video;
              }
              video.src = url;
              video.setAttribute("autoplay", "autoplay");
              video.setAttribute("webkit-playsinline", "true");
              video.addEventListener("canplay", this.onVideoLoaded);
              video.addEventListener("error", function () { return _this.onVideoError(); });
              video.addEventListener("ended", function () { return _this.onVideoEnded(); });
              var firstPause = false;
              video.addEventListener("canplay", function () {
                  _this.waiting = false;
                  if (!firstPause) {
                      firstPause = true;
                      video.pause();
                  }
                  else {
                      if (_this.userPause) {
                          _this.pause();
                      }
                      else if (_this.userPlay) {
                          _this.play();
                      }
                  }
              });
              video.addEventListener("waiting", function () {
                  _this.waiting = true;
              });
              video.load();
              this.videoPlay();
              video.style.position = "absolute";
              video.style.top = "0px";
              video.style.zIndex = "-88888";
              video.style.left = "0px";
              video.height = 1;
              video.width = 1;
          };
          /**
           * @inheritDoc
           */
          WebVideo.prototype.play = function (startTime, loop) {
              var _this = this;
              if (loop === void 0) { loop = false; }
              if (this.loaded == false) {
                  this.load(this.src);
                  this.once(egret.Event.COMPLETE, function (e) { return _this.play(startTime, loop); }, this);
                  return;
              }
              this.isPlayed = true;
              var video = this.video;
              if (startTime != undefined)
                  video.currentTime = +startTime || 0;
              video.loop = !!loop;
              if (egret.Capabilities.isMobile) {
                  video.style.zIndex = "-88888"; //移动端，就算设置成最小，只要全屏，都会在最上层，而且在自动退出去后，不担心挡住canvas
              }
              else {
                  video.style.zIndex = "9999";
              }
              video.style.position = "absolute";
              video.style.top = "0px";
              video.style.left = "0px";
              video.height = video.videoHeight;
              video.width = video.videoWidth;
              if (egret.Capabilities.os != "Windows PC" && egret.Capabilities.os != "Mac OS") {
                  window.setTimeout(function () {
                      video.width = 0;
                  }, 1000);
              }
              this.checkFullScreen(this._fullscreen);
          };
          WebVideo.prototype.videoPlay = function () {
              this.userPause = false;
              if (this.waiting) {
                  this.userPlay = true;
                  return;
              }
              this.userPlay = false;
              this.video.play();
          };
          WebVideo.prototype.checkFullScreen = function (playFullScreen) {
              var video = this.video;
              if (playFullScreen) {
                  if (video.parentElement == null) {
                      video.removeAttribute("webkit-playsinline");
                      document.body.appendChild(video);
                  }
                  egret.stopTick(this.markDirty, this);
                  this.goFullscreen();
              }
              else {
                  if (video.parentElement != null) {
                      video.parentElement.removeChild(video);
                  }
                  video.setAttribute("webkit-playsinline", "true");
                  this.setFullScreenMonitor(false);
                  egret.startTick(this.markDirty, this);
                  if (egret.Capabilities.isMobile) {
                      this.video.currentTime = 0;
                      this.onVideoEnded();
                      return;
                  }
              }
              this.videoPlay();
          };
          WebVideo.prototype.goFullscreen = function () {
              var video = this.video;
              var fullscreenType;
              fullscreenType = wxgame.getPrefixStyleName('requestFullscreen', video);
              if (!video[fullscreenType]) {
                  fullscreenType = wxgame.getPrefixStyleName('requestFullScreen', video);
                  if (!video[fullscreenType]) {
                      return true;
                  }
              }
              video.removeAttribute("webkit-playsinline");
              video[fullscreenType]();
              this.setFullScreenMonitor(true);
              return true;
          };
          WebVideo.prototype.setFullScreenMonitor = function (use) {
              var video = this.video;
              if (use) {
                  video.addEventListener("mozfullscreenchange", this.screenChanged);
                  video.addEventListener("webkitfullscreenchange", this.screenChanged);
                  video.addEventListener("mozfullscreenerror", this.screenError);
                  video.addEventListener("webkitfullscreenerror", this.screenError);
              }
              else {
                  video.removeEventListener("mozfullscreenchange", this.screenChanged);
                  video.removeEventListener("webkitfullscreenchange", this.screenChanged);
                  video.removeEventListener("mozfullscreenerror", this.screenError);
                  video.removeEventListener("webkitfullscreenerror", this.screenError);
              }
          };
          WebVideo.prototype.screenError = function () {
              egret.$error(3014);
          };
          WebVideo.prototype.exitFullscreen = function () {
              //退出全屏
              if (document['exitFullscreen']) {
                  document['exitFullscreen']();
              }
              else if (document['msExitFullscreen']) {
                  document['msExitFullscreen']();
              }
              else if (document['mozCancelFullScreen']) {
                  document['mozCancelFullScreen']();
              }
              else if (document['oCancelFullScreen']) {
                  document['oCancelFullScreen']();
              }
              else if (document['webkitExitFullscreen']) {
                  document['webkitExitFullscreen']();
              }
              else {
              }
          };
          /**
           * @private
           *
           */
          WebVideo.prototype.onVideoEnded = function () {
              this.pause();
              this.isPlayed = false;
              this.dispatchEventWith(egret.Event.ENDED);
          };
          /**
           * @private
           *
           */
          WebVideo.prototype.onVideoError = function () {
              this.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
          };
          /**
           * @inheritDoc
           */
          WebVideo.prototype.close = function () {
              var _this = this;
              this.closed = true;
              this.video.removeEventListener("canplay", this.onVideoLoaded);
              this.video.removeEventListener("error", function () { return _this.onVideoError(); });
              this.video.removeEventListener("ended", function () { return _this.onVideoEnded(); });
              this.pause();
              if (this.loaded == false && this.video)
                  this.video.src = "";
              if (this.video && this.video.parentElement) {
                  this.video.parentElement.removeChild(this.video);
                  this.video = null;
              }
              this.loaded = false;
          };
          /**
           * @inheritDoc
           */
          WebVideo.prototype.pause = function () {
              this.userPlay = false;
              if (this.waiting) {
                  this.userPause = true;
                  return;
              }
              this.userPause = false;
              egret.stopTick(this.markDirty, this);
          };
          Object.defineProperty(WebVideo.prototype, "volume", {
              /**
               * @inheritDoc
               */
              get: function () {
                  if (!this.video)
                      return 1;
                  return this.video.volume;
              },
              /**
               * @inheritDoc
               */
              set: function (value) {
                  if (!this.video)
                      return;
                  this.video.volume = value;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebVideo.prototype, "position", {
              /**
               * @inheritDoc
               */
              get: function () {
                  if (!this.video)
                      return 0;
                  return this.video.currentTime;
              },
              /**
               * @inheritDoc
               */
              set: function (value) {
                  if (!this.video)
                      return;
                  this.video.currentTime = value;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebVideo.prototype, "fullscreen", {
              /**
               * @inheritDoc
               */
              get: function () {
                  return this._fullscreen;
              },
              /**
               * @inheritDoc
               */
              set: function (value) {
                  if (egret.Capabilities.isMobile) {
                      return;
                  }
                  this._fullscreen = !!value;
                  if (this.video && this.video.paused == false) {
                      this.checkFullScreen(this._fullscreen);
                  }
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebVideo.prototype, "bitmapData", {
              /**
               * @inheritDoc
               */
              get: function () {
                  if (!this.video || !this.loaded)
                      return null;
                  if (!this._bitmapData) {
                      this.video.width = this.video.videoWidth;
                      this.video.height = this.video.videoHeight;
                      this._bitmapData = new egret.BitmapData(this.video);
                      this._bitmapData.$deleteSource = false;
                  }
                  return this._bitmapData;
              },
              enumerable: true,
              configurable: true
          });
          WebVideo.prototype.loadPoster = function () {
              var _this = this;
              var poster = this.poster;
              if (!poster)
                  return;
              var imageLoader = new egret.ImageLoader();
              imageLoader.once(egret.Event.COMPLETE, function (e) {
                  var posterData = imageLoader.data;
                  _this.posterData = imageLoader.data;
                  _this.posterData.width = _this.getPlayWidth();
                  _this.posterData.height = _this.getPlayHeight();
              }, this);
              imageLoader.load(poster);
          };
          /**
           * @private
           */
          WebVideo.prototype.$measureContentBounds = function (bounds) {
              var bitmapData = this.bitmapData;
              var posterData = this.posterData;
              if (bitmapData) {
                  bounds.setTo(0, 0, this.getPlayWidth(), this.getPlayHeight());
              }
              else if (posterData) {
                  bounds.setTo(0, 0, this.getPlayWidth(), this.getPlayHeight());
              }
              else {
                  bounds.setEmpty();
              }
          };
          WebVideo.prototype.getPlayWidth = function () {
              if (!isNaN(this.widthSet)) {
                  return this.widthSet;
              }
              if (this.bitmapData) {
                  return this.bitmapData.width;
              }
              if (this.posterData) {
                  return this.posterData.width;
              }
              return NaN;
          };
          WebVideo.prototype.getPlayHeight = function () {
              if (!isNaN(this.heightSet)) {
                  return this.heightSet;
              }
              if (this.bitmapData) {
                  return this.bitmapData.height;
              }
              if (this.posterData) {
                  return this.posterData.height;
              }
              return NaN;
          };
          /**
           * @private
           */
          WebVideo.prototype.$updateRenderNode = function () {
              var node = this.$renderNode;
              var bitmapData = this.bitmapData;
              var posterData = this.posterData;
              var width = this.getPlayWidth();
              var height = this.getPlayHeight();
              if ((!this.isPlayed || egret.Capabilities.isMobile) && posterData) {
                  node.image = posterData;
                  node.imageWidth = width;
                  node.imageHeight = height;
                  node.drawImage(0, 0, posterData.width, posterData.height, 0, 0, width, height);
              }
              else if (this.isPlayed && bitmapData) {
                  node.image = bitmapData;
                  node.imageWidth = bitmapData.width;
                  node.imageHeight = bitmapData.height;
                  egret.WebGLUtils.deleteWebGLTexture(bitmapData.webGLTexture);
                  bitmapData.webGLTexture = null;
                  node.drawImage(0, 0, bitmapData.width, bitmapData.height, 0, 0, width, height);
              }
          };
          WebVideo.prototype.markDirty = function () {
              this.$renderDirty = true;
              return true;
          };
          /**
           * @private
           * 设置显示高度
           */
          WebVideo.prototype.$setHeight = function (value) {
              this.heightSet = +value || 0;
              _super.prototype.$setHeight.call(this, value);
          };
          /**
           * @private
           * 设置显示宽度
           */
          WebVideo.prototype.$setWidth = function (value) {
              this.widthSet = +value || 0;
              _super.prototype.$setWidth.call(this, value);
          };
          Object.defineProperty(WebVideo.prototype, "paused", {
              get: function () {
                  if (this.video) {
                      return this.video.paused;
                  }
                  return true;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebVideo.prototype, "length", {
              /**
               * @inheritDoc
               */
              get: function () {
                  if (this.video) {
                      return this.video.duration;
                  }
                  throw new Error("Video not loaded!");
              },
              enumerable: true,
              configurable: true
          });
          return WebVideo;
      }(egret.DisplayObject));
      wxgame.WebVideo = WebVideo;
      __reflect(WebVideo.prototype, "egret.wxgame.WebVideo", ["egret.Video", "egret.DisplayObject"]);
      egret.Video = WebVideo;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebHttpRequest = (function (_super) {
          __extends(WebHttpRequest, _super);
          /**
           * @private
           */
          function WebHttpRequest() {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this._url = "";
              _this._method = "";
              return _this;
          }
          Object.defineProperty(WebHttpRequest.prototype, "response", {
              /**
               * @private
               * 本次请求返回的数据，数据类型根据responseType设置的值确定。
               */
              get: function () {
                  if (this._response) {
                      return this._response;
                  }
                  return null;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebHttpRequest.prototype, "responseType", {
              /**
               * @private
               * 设置返回的数据格式，请使用 HttpResponseType 里定义的枚举值。设置非法的值或不设置，都将使用HttpResponseType.TEXT。
               */
              get: function () {
                  return this._responseType;
              },
              set: function (value) {
                  this._responseType = value;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebHttpRequest.prototype, "withCredentials", {
              /**
               * @private
               * 表明在进行跨站(cross-site)的访问控制(Access-Control)请求时，是否使用认证信息(例如cookie或授权的header)。 默认为 false。(这个标志不会影响同站的请求)
               */
              get: function () {
                  return this._withCredentials;
              },
              set: function (value) {
                  this._withCredentials = value;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * @private
           * 初始化一个请求.注意，若在已经发出请求的对象上调用此方法，相当于立即调用abort().
           * @param url 该请求所要访问的URL该请求所要访问的URL
           * @param method 请求所使用的HTTP方法， 请使用 HttpMethod 定义的枚举值.
           */
          WebHttpRequest.prototype.open = function (url, method) {
              if (method === void 0) { method = "GET"; }
              this._url = url;
              this._method = method;
          };
          WebHttpRequest.prototype.readFileAsync = function () {
              var self = this;
              var onSuccessFunc = function (content) {
                  self._response = content;
                  self.dispatchEventWith(egret.Event.COMPLETE);
              };
              var onErrorFunc = function () {
                  self.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
              };
              var fs = wx.getFileSystemManager();
              if (self.responseType == "arraybuffer") {
                  //不传 encoding 默认返回二进制格式，传了 encoding:binary 反而返回 string 格式
                  fs.readFile({
                      filePath: self._url,
                      success: function (_a) {
                          var data = _a.data;
                          onSuccessFunc(data);
                      },
                      fail: function () {
                          onErrorFunc();
                      }
                  });
              }
              else {
                  fs.readFile({
                      filePath: self._url,
                      encoding: 'utf8',
                      success: function (_a) {
                          var data = _a.data;
                          onSuccessFunc(data);
                      },
                      fail: function () {
                          onErrorFunc();
                      }
                  });
              }
          };
          /**
           * @private
           * 发送请求.
           * @param data 需要发送的数据
           */
          WebHttpRequest.prototype.send = function (data) {
              this._response = undefined;
              if (!this.isNetUrl(this._url)) {
                  this.readFileAsync();
              }
              else {
                  var self_1 = this;
                  wx.request({
                      data: data,
                      url: this._url,
                      method: this._method,
                      header: this.headerObj,
                      responseType: this.responseType,
                      success: function success(_ref) {
                          var data = _ref.data, statusCode = _ref.statusCode, header = _ref.header;
                          if (statusCode != 200) {
                              self_1.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
                              return;
                          }
                          if (typeof data !== 'string' && !(data instanceof ArrayBuffer)) {
                              try {
                                  data = JSON.stringify(data);
                              }
                              catch (e) {
                                  data = data;
                              }
                          }
                          self_1._responseHeader = header;
                          self_1._response = data;
                          self_1.dispatchEventWith(egret.Event.COMPLETE);
                      },
                      fail: function fail(_ref2) {
                          // var errMsg = _ref2.errMsg;
                          self_1.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
                      }
                  });
              }
          };
          /**
           * 是否是网络地址
           * @param url
           * @returns {boolean}
           */
          WebHttpRequest.prototype.isNetUrl = function (url) {
              return url.indexOf("http://") != -1 || url.indexOf("HTTP://") != -1 || url.indexOf("https://") != -1 || url.indexOf("HTTPS://") != -1;
          };
          /**
           * @private
           * 如果请求已经被发送,则立刻中止请求.
           */
          WebHttpRequest.prototype.abort = function () {
          };
          /**
           * @private
           * 返回所有响应头信息(响应头名和值), 如果响应头还没接受,则返回"".
           */
          WebHttpRequest.prototype.getAllResponseHeaders = function () {
              var responseHeader = this._responseHeader;
              if (!responseHeader) {
                  return null;
              }
              return Object.keys(responseHeader).map(function (header) {
                  return header + ': ' + responseHeader[header];
              }).join('\n');
          };
          /**
           * @private
           * 给指定的HTTP请求头赋值.在这之前,您必须确认已经调用 open() 方法打开了一个url.
           * @param header 将要被赋值的请求头名称.
           * @param value 给指定的请求头赋的值.
           */
          WebHttpRequest.prototype.setRequestHeader = function (header, value) {
              if (!this.headerObj) {
                  this.headerObj = {};
              }
              this.headerObj[header] = value;
          };
          /**
           * @private
           * 返回指定的响应头的值, 如果响应头还没被接受,或该响应头不存在,则返回"".
           * @param header 要返回的响应头名称
           */
          WebHttpRequest.prototype.getResponseHeader = function (header) {
              if (!this._responseHeader) {
                  return null;
              }
              var result = this._responseHeader[header];
              return result ? result : "";
          };
          /**
           * @private
           */
          WebHttpRequest.prototype.updateProgress = function (event) {
              if (event.lengthComputable) {
                  egret.ProgressEvent.dispatchProgressEvent(this, egret.ProgressEvent.PROGRESS, event.loaded, event.total);
              }
          };
          return WebHttpRequest;
      }(egret.EventDispatcher));
      wxgame.WebHttpRequest = WebHttpRequest;
      __reflect(WebHttpRequest.prototype, "egret.wxgame.WebHttpRequest", ["egret.HttpRequest"]);
      egret.HttpRequest = WebHttpRequest;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      var winURL = window["URL"] || window["webkitURL"];
      /**
       * @private
       * ImageLoader 类可用于加载图像（JPG、PNG 或 GIF）文件。使用 load() 方法来启动加载。被加载的图像对象数据将存储在 ImageLoader.data 属性上 。
       */
      var WebImageLoader = (function (_super) {
          __extends(WebImageLoader, _super);
          function WebImageLoader() {
              var _this = _super !== null && _super.apply(this, arguments) || this;
              /**
               * @private
               * 使用 load() 方法加载成功的 BitmapData 图像数据。
               */
              _this.data = null;
              /**
               * @private
               * 当从其他站点加载一个图片时，指定是否启用跨域资源共享(CORS)，默认值为null。
               * 可以设置为"anonymous","use-credentials"或null,设置为其他值将等同于"anonymous"。
               */
              _this._crossOrigin = null;
              /**
               * @private
               * 标记crossOrigin有没有被设置过,设置过之后使用设置的属性
               */
              _this._hasCrossOriginSet = false;
              /**
               * @private
               */
              _this.currentImage = null;
              /**
               * @private
               */
              _this.request = null;
              return _this;
          }
          Object.defineProperty(WebImageLoader.prototype, "crossOrigin", {
              get: function () {
                  return this._crossOrigin;
              },
              set: function (value) {
                  this._hasCrossOriginSet = true;
                  this._crossOrigin = value;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * @private
           * 启动一次图像加载。注意：若之前已经调用过加载请求，重新调用 load() 将终止先前的请求，并开始新的加载。
           * @param url 要加载的图像文件的地址。
           */
          WebImageLoader.prototype.load = function (url) {
              this.loadImage(url);
          };
          /**
           * @private
           */
          WebImageLoader.prototype.loadImage = function (src) {
              var image = new Image();
              this.data = null;
              this.currentImage = image;
              if (this._hasCrossOriginSet) {
                  if (this._crossOrigin) {
                      image.crossOrigin = this._crossOrigin;
                  }
              }
              else {
                  if (WebImageLoader.crossOrigin) {
                      image.crossOrigin = WebImageLoader.crossOrigin;
                  }
              }
              /*else {
                  if (image.hasAttribute("crossOrigin")) {//兼容猎豹
                      image.removeAttribute("crossOrigin");
                  }
              }*/
              image.onload = this.onImageComplete.bind(this);
              image.onerror = this.onLoadError.bind(this);
              image.src = src;
          };
          /**
           * @private
           */
          WebImageLoader.prototype.onImageComplete = function (event) {
              var image = this.getImage(event);
              if (!image) {
                  return;
              }
              this.data = new egret.BitmapData(image);
              if (wxgame.preUploadTexture && egret.Capabilities.renderMode == "webgl") {
                  wxgame.WebGLRenderContext.getInstance(null, null).getWebGLTexture(this.data);
              }
              var self = this;
              window.setTimeout(function () {
                  self.dispatchEventWith(egret.Event.COMPLETE);
              }, 0);
          };
          /**
           * @private
           */
          WebImageLoader.prototype.onLoadError = function (event) {
              var image = this.getImage(event);
              if (!image) {
                  return;
              }
              this.dispatchIOError(image.src);
          };
          WebImageLoader.prototype.dispatchIOError = function (url) {
              var self = this;
              window.setTimeout(function () {
                  if (true && !self.hasEventListener(egret.IOErrorEvent.IO_ERROR)) {
                      egret.$error(1011, url);
                  }
                  self.dispatchEventWith(egret.IOErrorEvent.IO_ERROR);
              }, 0);
          };
          /**
           * @private
           */
          WebImageLoader.prototype.getImage = function (event) {
              var image = event.target;
              var url = image.src;
              image.onerror = null;
              image.onload = null;
              if (this.currentImage !== image) {
                  return null;
              }
              this.currentImage = null;
              return image;
          };
          /**
           * @private
           * 指定是否启用跨域资源共享,如果ImageLoader实例有设置过crossOrigin属性将使用设置的属性
           */
          WebImageLoader.crossOrigin = null;
          return WebImageLoader;
      }(egret.EventDispatcher));
      wxgame.WebImageLoader = WebImageLoader;
      __reflect(WebImageLoader.prototype, "egret.wxgame.WebImageLoader", ["egret.ImageLoader"]);
      egret.ImageLoader = WebImageLoader;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @classdesc
       * @extends egret.StageText
       * @private
       */
      var HTML5StageText = (function (_super) {
          __extends(HTML5StageText, _super);
          /**
           * @private
           */
          function HTML5StageText() {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.textValue = "";
              _this.onKeyboardComplete = _this.onKeyboardComplete.bind(_this);
              _this.onKeyboardInput = _this.onKeyboardInput.bind(_this);
              return _this;
          }
          /**
           * @private
           *
           * @param textfield
           */
          HTML5StageText.prototype.$setTextField = function (textfield) {
              this.$textfield = textfield;
              return true;
          };
          /**
           * @private
           *
           */
          HTML5StageText.prototype.$addToStage = function () {
          };
          /**
           * @private
           *
           */
          HTML5StageText.prototype.$show = function () {
              var info = {
                  defaultValue: this.$textfield.text,
                  multiple: this.$textfield.multiline,
                  confirmHold: true,
                  confirmType: 'done',
                  fail: function (res) {
                      console.log(res.errMsg);
                  }
              };
              if (this.$textfield.maxChars) {
                  info.maxLength = this.$textfield.maxChars;
              }
              wx.showKeyboard(info);
              wx.onKeyboardConfirm(this.onKeyboardComplete);
              wx.onKeyboardComplete(this.onKeyboardComplete);
              wx.onKeyboardInput(this.onKeyboardInput);
              this.dispatchEvent(new egret.Event("focus"));
          };
          HTML5StageText.prototype.onKeyboardInput = function (data) {
              this.textValue = data.value;
              egret.Event.dispatchEvent(this, "updateText", false);
          };
          HTML5StageText.prototype.onKeyboardComplete = function (res) {
              this.$textfield.text = res.value;
              this.$hide();
          };
          /**
           * @private
           */
          HTML5StageText.prototype.$hide = function () {
              wx.offKeyboardComplete();
              wx.offKeyboardConfirm();
              wx.offKeyboardInput();
              wx.hideKeyboard({});
              this.dispatchEvent(new egret.Event("blur"));
          };
          /**
           * @private
           *
           * @returns
           */
          HTML5StageText.prototype.$getText = function () {
              if (!this.textValue) {
                  this.textValue = "";
              }
              return this.textValue;
          };
          /**
           * @private
           *
           * @param value
           */
          HTML5StageText.prototype.$setText = function (value) {
              this.textValue = value;
              // this.resetText();
              return true;
          };
          /**
           * @private
           */
          HTML5StageText.prototype.$setColor = function (value) {
              return true;
          };
          HTML5StageText.prototype.$onBlur = function () {
          };
          /**
           * @private
           *
           */
          HTML5StageText.prototype.$removeFromStage = function () {
          };
          /**
           * 修改位置
           * @private
           */
          HTML5StageText.prototype.$resetStageText = function () {
          };
          return HTML5StageText;
      }(egret.EventDispatcher));
      wxgame.HTML5StageText = HTML5StageText;
      __reflect(HTML5StageText.prototype, "egret.wxgame.HTML5StageText", ["egret.StageText"]);
      egret.StageText = HTML5StageText;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var context = null;
      /**
       * @private
       */
      var fontCache = {};
      /**
       * 测量文本在指定样式下的宽度。
       * @param text 要测量的文本内容。
       * @param fontFamily 字体名称
       * @param fontSize 字体大小
       * @param bold 是否粗体
       * @param italic 是否斜体
       */
      function measureText(text, fontFamily, fontSize, bold, italic) {
          if (!context) {
              createContext();
          }
          var font = "";
          if (italic)
              font += "italic ";
          if (bold)
              font += "bold ";
          font += (fontSize || 12) + "px ";
          font += (fontFamily || "Arial");
          context.font = font;
          return context.measureText(text).width;
      }
      /**
       * @private
       */
      function createContext() {
          context = egret.sys.canvasHitTestBuffer.context;
          context.textAlign = "left";
          context.textBaseline = "middle";
      }
      egret.sys.measureText = measureText;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * 创建一个canvas。
       */
      function createCanvas(width, height) {
          var canvas = document.createElement("canvas");
          if (!isNaN(width) && !isNaN(height)) {
              canvas.width = width;
              canvas.height = height;
          }
          var context = canvas.getContext("2d");
          if (context["imageSmoothingEnabled"] === undefined) {
              var keys = ["webkitImageSmoothingEnabled", "mozImageSmoothingEnabled", "msImageSmoothingEnabled"];
              var key_1;
              for (var i = keys.length - 1; i >= 0; i--) {
                  key_1 = keys[i];
                  if (context[key_1] !== void 0) {
                      break;
                  }
              }
              try {
                  Object.defineProperty(context, "imageSmoothingEnabled", {
                      get: function () {
                          return this[key_1];
                      },
                      set: function (value) {
                          this[key_1] = value;
                      }
                  });
              }
              catch (e) {
                  context["imageSmoothingEnabled"] = context[key_1];
              }
          }
          return canvas;
      }
      var sharedCanvas;
      /**
       * @private
       * Canvas2D渲染缓冲
       */
      var CanvasRenderBuffer = (function () {
          function CanvasRenderBuffer(width, height, root) {
              if (root) {
                  if (wxgame.isSubContext) {
                      this.surface = window["sharedCanvas"];
                  }
                  else {
                      this.surface = window["canvas"];
                  }
              }
              else {
                  this.surface = createCanvas(width, height);
              }
              this.context = this.surface.getContext("2d");
              if (this.context) {
                  this.context.$offsetX = 0;
                  this.context.$offsetY = 0;
              }
          }
          Object.defineProperty(CanvasRenderBuffer.prototype, "width", {
              /**
               * 渲染缓冲的宽度，以像素为单位。
               * @readOnly
               */
              get: function () {
                  return this.surface.width;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(CanvasRenderBuffer.prototype, "height", {
              /**
               * 渲染缓冲的高度，以像素为单位。
               * @readOnly
               */
              get: function () {
                  return this.surface.height;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * 改变渲染缓冲的大小并清空缓冲区
           * @param width 改变后的宽
           * @param height 改变后的高
           * @param useMaxSize 若传入true，则将改变后的尺寸与已有尺寸对比，保留较大的尺寸。
           */
          CanvasRenderBuffer.prototype.resize = function (width, height, useMaxSize) {
              var surface = this.surface;
              if (wxgame.isSubContext) {
                  return;
              }
              if (useMaxSize) {
                  var change = false;
                  if (surface.width < width) {
                      surface.width = width;
                      if (egret.Capabilities.renderMode === 'canvas') {
                          window["sharedCanvas"].width = width;
                      }
                      change = true;
                  }
                  if (surface.height < height) {
                      surface.height = height;
                      if (egret.Capabilities.renderMode === 'canvas') {
                          window["sharedCanvas"].height = height;
                      }
                      change = true;
                  }
                  //尺寸没有变化时,将绘制属性重置
                  if (!change) {
                      this.context.globalCompositeOperation = "source-over";
                      this.context.setTransform(1, 0, 0, 1, 0, 0);
                      this.context.globalAlpha = 1;
                  }
              }
              else {
                  if (surface.width != width) {
                      surface.width = width;
                      if (egret.Capabilities.renderMode === 'canvas') {
                          window["sharedCanvas"].width = width;
                      }
                  }
                  if (surface.height != height) {
                      surface.height = height;
                      if (egret.Capabilities.renderMode === 'canvas') {
                          window["sharedCanvas"].height = height;
                      }
                  }
              }
              this.clear();
          };
          /**
           * 获取指定区域的像素
           */
          CanvasRenderBuffer.prototype.getPixels = function (x, y, width, height) {
              if (width === void 0) { width = 1; }
              if (height === void 0) { height = 1; }
              return this.context.getImageData(x, y, width, height).data;
          };
          /**
           * 转换成base64字符串，如果图片（或者包含的图片）跨域，则返回null
           * @param type 转换的类型，如: "image/png","image/jpeg"
           */
          CanvasRenderBuffer.prototype.toDataURL = function (type, encoderOptions) {
              return this.surface.toDataURL(type, encoderOptions);
          };
          /**
           * 清空缓冲区数据
           */
          CanvasRenderBuffer.prototype.clear = function () {
              this.context.setTransform(1, 0, 0, 1, 0, 0);
              this.context.clearRect(0, 0, this.surface.width, this.surface.height);
          };
          /**
           * 销毁绘制对象
           */
          CanvasRenderBuffer.prototype.destroy = function () {
              this.surface.width = this.surface.height = 0;
          };
          return CanvasRenderBuffer;
      }());
      wxgame.CanvasRenderBuffer = CanvasRenderBuffer;
      __reflect(CanvasRenderBuffer.prototype, "egret.wxgame.CanvasRenderBuffer", ["egret.sys.RenderBuffer"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided this the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebTouchHandler = (function (_super) {
          __extends(WebTouchHandler, _super);
          /**
           * @private
           */
          function WebTouchHandler(stage, canvas) {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.onTouchBegin = function (event) {
                  var location = _this.getLocation(event);
                  _this.touch.onTouchBegin(location.x, location.y, event.identifier);
              };
              /**
               * @private
               */
              _this.onTouchMove = function (event) {
                  var location = _this.getLocation(event);
                  _this.touch.onTouchMove(location.x, location.y, event.identifier);
              };
              /**
               * @private
               */
              _this.onTouchEnd = function (event) {
                  var location = _this.getLocation(event);
                  _this.touch.onTouchEnd(location.x, location.y, event.identifier);
              };
              /**
               * @private
               */
              _this.scaleX = 1;
              /**
               * @private
               */
              _this.scaleY = 1;
              /**
               * @private
               */
              _this.rotation = 0;
              _this.canvas = canvas;
              _this.touch = new egret.sys.TouchHandler(stage);
              _this.addTouchListener();
              return _this;
          }
          /**
           * @private
           *
           */
          WebTouchHandler.prototype.addTouchListener = function () {
              var self = this;
              if (wxgame.isSubContext) {
                  wx.onTouchStart(function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchBegin(event.changedTouches[i]);
                      }
                  });
                  wx.onTouchMove(function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchMove(event.changedTouches[i]);
                      }
                  });
                  wx.onTouchEnd(function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchEnd(event.changedTouches[i]);
                      }
                  });
                  wx.onTouchCancel(function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchEnd(event.changedTouches[i]);
                      }
                  });
              }
              else {
                  self.canvas.addEventListener("touchstart", function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchBegin(event.changedTouches[i]);
                      }
                      self.prevent(event);
                  }, false);
                  self.canvas.addEventListener("touchmove", function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchMove(event.changedTouches[i]);
                      }
                      self.prevent(event);
                  }, false);
                  self.canvas.addEventListener("touchend", function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchEnd(event.changedTouches[i]);
                      }
                      self.prevent(event);
                  }, false);
                  self.canvas.addEventListener("touchcancel", function (event) {
                      var l = event.changedTouches.length;
                      for (var i = 0; i < l; i++) {
                          self.onTouchEnd(event.changedTouches[i]);
                      }
                      self.prevent(event);
                  }, false);
              }
          };
          /**
           * @private
           */
          WebTouchHandler.prototype.prevent = function (event) {
              event.stopPropagation();
              if (event["isScroll"] != true && !this.canvas['userTyping']) {
                  event.preventDefault();
              }
          };
          /**
           * @private
           */
          WebTouchHandler.prototype.getLocation = function (event) {
              //   event.identifier = +event.identifier || 0;        wxgame 内核该属性只读
              var doc = document.documentElement;
              var box = this.canvas.getBoundingClientRect();
              var left = box.left;
              var top = box.top;
              var x = event.pageX - left, newx = x;
              var y = event.pageY - top, newy = y;
              if (this.rotation == 90) {
                  newx = y;
                  newy = box.width - x;
              }
              else if (this.rotation == -90) {
                  newx = box.height - y;
                  newy = x;
              }
              newx = newx / this.scaleX;
              newy = newy / this.scaleY;
              return egret.$TempPoint.setTo(Math.round(newx), Math.round(newy));
          };
          /**
           * @private
           * 更新屏幕当前的缩放比例，用于计算准确的点击位置。
           * @param scaleX 水平方向的缩放比例。
           * @param scaleY 垂直方向的缩放比例。
           */
          WebTouchHandler.prototype.updateScaleMode = function (scaleX, scaleY, rotation) {
              this.scaleX = scaleX;
              this.scaleY = scaleY;
              this.rotation = rotation;
          };
          /**
           * @private
           * 更新同时触摸点的数量
           */
          WebTouchHandler.prototype.$updateMaxTouches = function () {
              this.touch.$initMaxTouches();
          };
          return WebTouchHandler;
      }(egret.HashObject));
      wxgame.WebTouchHandler = WebTouchHandler;
      __reflect(WebTouchHandler.prototype, "egret.wxgame.WebTouchHandler");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      wxgame.WebLifeCycleHandler = function (context) {
          wx.onShow(function () {
              context.resume();
          });
          wx.onHide(function () {
              context.pause();
          });
      };
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var AudioType = (function () {
          function AudioType() {
          }
          /**
           * @private
           */
          AudioType.WEB_AUDIO = 2;
          /**
           * @private
           */
          AudioType.HTML5_AUDIO = 3;
          return AudioType;
      }());
      wxgame.AudioType = AudioType;
      __reflect(AudioType.prototype, "egret.wxgame.AudioType");
      /**
       * html5兼容性配置
       * @private
       */
      var Html5Capatibility = (function (_super) {
          __extends(Html5Capatibility, _super);
          /**
           * @private
           */
          function Html5Capatibility() {
              return _super.call(this) || this;
          }
          /**
           * @private
           *
           */
          Html5Capatibility.$init = function () {
              var ua = navigator.userAgent.toLowerCase();
              Html5Capatibility.ua = ua;
              Html5Capatibility._canUseBlob = false;
              var canUseWebAudio = window["AudioContext"] || window["webkitAudioContext"] || window["mozAudioContext"];
              if (canUseWebAudio) {
                  try {
                      //防止某些chrome版本创建异常问题
                      wxgame.WebAudioDecode.ctx = new (window["AudioContext"] || window["webkitAudioContext"] || window["mozAudioContext"])();
                  }
                  catch (e) {
                      canUseWebAudio = false;
                  }
              }
              var audioType = Html5Capatibility._audioType;
              var checkAudioType;
              if ((audioType == AudioType.WEB_AUDIO && canUseWebAudio) || audioType == AudioType.HTML5_AUDIO) {
                  checkAudioType = false;
                  Html5Capatibility.setAudioType(audioType);
              }
              else {
                  checkAudioType = true;
                  Html5Capatibility.setAudioType(AudioType.HTML5_AUDIO);
              }
              if (ua.indexOf("android") >= 0) {
                  if (checkAudioType && canUseWebAudio) {
                      Html5Capatibility.setAudioType(AudioType.WEB_AUDIO);
                  }
              }
              else if (ua.indexOf("iphone") >= 0 || ua.indexOf("ipad") >= 0 || ua.indexOf("ipod") >= 0) {
                  if (Html5Capatibility.getIOSVersion() >= 7) {
                      Html5Capatibility._canUseBlob = true;
                      if (checkAudioType && canUseWebAudio) {
                          Html5Capatibility.setAudioType(AudioType.WEB_AUDIO);
                      }
                  }
              }
              var winURL = window["URL"] || window["webkitURL"];
              if (!winURL) {
                  Html5Capatibility._canUseBlob = false;
              }
              if (ua.indexOf("egretnative") >= 0) {
                  Html5Capatibility.setAudioType(AudioType.HTML5_AUDIO);
                  Html5Capatibility._canUseBlob = true;
              }
              egret.Sound = Html5Capatibility._AudioClass;
          };
          Html5Capatibility.setAudioType = function (type) {
              Html5Capatibility._audioType = type;
              switch (type) {
                  case AudioType.WEB_AUDIO:
                      Html5Capatibility._AudioClass = wxgame.WebAudioSound;
                      break;
                  case AudioType.HTML5_AUDIO:
                      Html5Capatibility._AudioClass = wxgame.HtmlSound;
                      break;
              }
          };
          /**
           * @private
           * 获取ios版本
           * @returns {string}
           */
          Html5Capatibility.getIOSVersion = function () {
              var value = Html5Capatibility.ua.toLowerCase().match(/cpu [^\d]*\d.*like mac os x/)[0];
              return parseInt(value.match(/\d+(_\d)*/)[0]) || 0;
          };
          //当前浏览器版本是否支持blob
          Html5Capatibility._canUseBlob = false;
          //当前浏览器版本是否支持webaudio
          Html5Capatibility._audioType = 0;
          /**
           * @private
           */
          Html5Capatibility.ua = "";
          return Html5Capatibility;
      }(egret.HashObject));
      wxgame.Html5Capatibility = Html5Capatibility;
      __reflect(Html5Capatibility.prototype, "egret.wxgame.Html5Capatibility");
      /**
       * @private
       */
      var currentPrefix = null;
      /**
       * @private
       */
      function getPrefixStyleName(name, element) {
          var header = "";
          if (element != null) {
              header = getPrefix(name, element);
          }
          else {
              if (currentPrefix == null) {
                  var tempStyle = document.createElement('div').style;
                  currentPrefix = getPrefix("transform", tempStyle);
              }
              header = currentPrefix;
          }
          if (header == "") {
              return name;
          }
          return header + name.charAt(0).toUpperCase() + name.substring(1, name.length);
      }
      wxgame.getPrefixStyleName = getPrefixStyleName;
      /**
       * @private
       */
      function getPrefix(name, element) {
          if (name in element) {
              return "";
          }
          name = name.charAt(0).toUpperCase() + name.substring(1, name.length);
          var transArr = ["webkit", "ms", "Moz", "O"];
          for (var i = 0; i < transArr.length; i++) {
              var tempStyle = transArr[i] + name;
              if (tempStyle in element) {
                  return transArr[i];
              }
          }
          return "";
      }
      wxgame.getPrefix = getPrefix;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * 微信小游戏支持库版本号
       */
      wxgame.version = "1.1.3";
      /**
       * 运行环境是否为子域
       */
      wxgame.isSubContext = false;
      /**
       * 解决提交纹理异常临时方案
       */
      wxgame.preUploadTexture = false;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * 刷新所有Egret播放器的显示区域尺寸。仅当使用外部JavaScript代码动态修改了Egret容器大小时，需要手动调用此方法刷新显示区域。
       * 当网页尺寸发生改变时此方法会自动被调用。
       */
      function updateAllScreens() {
          if (!isRunning) {
              return;
          }
          // let containerList = document.querySelectorAll(".egret-player");
          // let length = containerList.length;
          // for (let i = 0; i < length; i++) {
          //     let container = containerList[i];
          //     let player = <WebPlayer>container["egret-player"];
          window['player'].updateScreenSize();
          // }
      }
      var isRunning = false;
      /**
       * @private
       * 网页加载完成，实例化页面中定义的Egret标签
       */
      function runEgret(options) {
          if (isRunning) {
              return;
          }
          isRunning = true;
          if (!options) {
              options = {};
          }
          wxgame.Html5Capatibility._audioType = options.audioType;
          wxgame.Html5Capatibility.$init();
          // WebGL上下文参数自定义
          if (options.renderMode == "webgl") {
              // WebGL抗锯齿默认关闭，提升PC及某些平台性能
              var antialias = options.antialias;
              wxgame.WebGLRenderContext.antialias = !!antialias;
              // WebGLRenderContext.antialias = (typeof antialias == undefined) ? true : antialias;
          }
          egret.sys.CanvasRenderBuffer = wxgame.CanvasRenderBuffer;
          setRenderMode(options.renderMode);
          var canvasScaleFactor;
          if (options.canvasScaleFactor) {
              canvasScaleFactor = options.canvasScaleFactor;
          }
          else if (options.calculateCanvasScaleFactor) {
              canvasScaleFactor = options.calculateCanvasScaleFactor(egret.sys.canvasHitTestBuffer.context);
          }
          else {
              //based on : https://github.com/jondavidjohn/hidpi-canvas-polyfill
              var context = egret.sys.canvasHitTestBuffer.context;
              var backingStore = context.backingStorePixelRatio ||
                  context.webkitBackingStorePixelRatio ||
                  context.mozBackingStorePixelRatio ||
                  context.msBackingStorePixelRatio ||
                  context.oBackingStorePixelRatio ||
                  context.backingStorePixelRatio || 1;
              canvasScaleFactor = (window.devicePixelRatio || 1) / backingStore;
          }
          egret.sys.DisplayList.$canvasScaleFactor = canvasScaleFactor;
          var ticker = egret.ticker;
          startTicker(ticker);
          if (options.screenAdapter) {
              egret.sys.screenAdapter = options.screenAdapter;
          }
          else if (!egret.sys.screenAdapter) {
              egret.sys.screenAdapter = new egret.sys.DefaultScreenAdapter();
          }
          // let list = document.querySelectorAll(".egret-player");
          // let length = list.length;
          // for (let i = 0; i < length; i++) {
          //     let container = <HTMLDivElement>list[i];
          //     let player = new WebPlayer(container, options);
          //     container["egret-player"] = player;
          // }
          var container = {};
          var player = new wxgame.WebPlayer(container, options);
          window['player'] = player;
          window.addEventListener("resize", function () {
              if (isNaN(resizeTimer)) {
                  resizeTimer = window.setTimeout(doResize, 300);
              }
          });
      }
      /**
       * 设置渲染模式。"auto","webgl","canvas"
       * @param renderMode
       */
      function setRenderMode(renderMode) {
          if (renderMode === "webgl") {
              egret.Capabilities["renderMode" + ""] = "webgl";
              egret.sys.RenderBuffer = wxgame.WebGLRenderBuffer;
              egret.sys.systemRenderer = new wxgame.WebGLRenderer();
              egret.sys.canvasRenderer = new egret.CanvasRenderer();
              egret.sys.customHitTestBuffer = new wxgame.WebGLRenderBuffer(3, 3);
              egret.sys.canvasHitTestBuffer = new wxgame.CanvasRenderBuffer(3, 3);
          }
          else {
              egret.Capabilities["renderMode" + ""] = "canvas";
              egret.sys.RenderBuffer = wxgame.CanvasRenderBuffer;
              egret.sys.systemRenderer = new egret.CanvasRenderer();
              egret.sys.canvasRenderer = egret.sys.systemRenderer;
              egret.sys.customHitTestBuffer = new wxgame.CanvasRenderBuffer(3, 3);
              egret.sys.canvasHitTestBuffer = egret.sys.customHitTestBuffer;
          }
      }
      /**
       * @private
       * 启动心跳计时器。
       */
      function startTicker(ticker) {
          var requestAnimationFrame = window["requestAnimationFrame"] ||
              window["webkitRequestAnimationFrame"] ||
              window["mozRequestAnimationFrame"] ||
              window["oRequestAnimationFrame"] ||
              window["msRequestAnimationFrame"];
          if (!requestAnimationFrame) {
              requestAnimationFrame = function (callback) {
                  return window.setTimeout(callback, 1000 / 60);
              };
          }
          requestAnimationFrame(onTick);
          function onTick() {
              ticker.update();
              requestAnimationFrame(onTick);
          }
      }
      egret.runEgret = runEgret;
      egret.updateAllScreens = updateAllScreens;
      var resizeTimer = NaN;
      function doResize() {
          resizeTimer = NaN;
          egret.updateAllScreens();
      }
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
if (true) {
  var language = navigator.language || navigator["browserLanguage"] || "en_US";
  language = language.replace("-", "_");
  if (language in egret.$locale_strings)
      egret.$language = language;
}
egret.Capabilities["runtimeType" + ""] = egret.RuntimeType.WXGAME;
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebCapability = (function () {
          function WebCapability() {
          }
          /**
           * @private
           * 检测系统属性
           */
          WebCapability.detect = function () {
              var capabilities = egret.Capabilities;
              var ua = navigator.userAgent.toLowerCase();
              capabilities["isMobile" + ""] = (ua.indexOf('mobile') != -1 || ua.indexOf('android') != -1);
              if (capabilities.isMobile) {
                  if (ua.indexOf("windows") < 0 && (ua.indexOf("iphone") != -1 || ua.indexOf("ipad") != -1 || ua.indexOf("ipod") != -1)) {
                      capabilities["os" + ""] = "iOS";
                  }
                  else if (ua.indexOf("android") != -1 && ua.indexOf("linux") != -1) {
                      capabilities["os" + ""] = "Android";
                  }
                  else if (ua.indexOf("windows") != -1) {
                      capabilities["os" + ""] = "Windows Phone";
                  }
              }
              else {
                  if (ua.indexOf("windows nt") != -1) {
                      capabilities["os" + ""] = "Windows PC";
                  }
                  else if (ua.indexOf("mac os") != -1) {
                      capabilities["os" + ""] = "Mac OS";
                  }
              }
              var language = (navigator.language || navigator["browserLanguage"]).toLowerCase();
              var strings = language.split("-");
              if (strings.length > 1) {
                  strings[1] = strings[1].toUpperCase();
              }
              capabilities["language" + ""] = strings.join("-");
              WebCapability.injectUIntFixOnIE9();
          };
          WebCapability.injectUIntFixOnIE9 = function () {
              if (/msie 9.0/i.test(navigator.userAgent) && !/opera/i.test(navigator.userAgent)) {
                  var IEBinaryToArray_ByteStr_Script = "<!-- IEBinaryToArray_ByteStr -->\r\n" +
                      "<script type='text/vbscript' language='VBScript'>\r\n" +
                      "Function IEBinaryToArray_ByteStr(Binary)\r\n" +
                      "   IEBinaryToArray_ByteStr = CStr(Binary)\r\n" +
                      "End Function\r\n" +
                      "Function IEBinaryToArray_ByteStr_Last(Binary)\r\n" +
                      "   Dim lastIndex\r\n" +
                      "   lastIndex = LenB(Binary)\r\n" +
                      "   if lastIndex mod 2 Then\r\n" +
                      "       IEBinaryToArray_ByteStr_Last = Chr( AscB( MidB( Binary, lastIndex, 1 ) ) )\r\n" +
                      "   Else\r\n" +
                      "       IEBinaryToArray_ByteStr_Last = " + '""' + "\r\n" +
                      "   End If\r\n" +
                      "End Function\r\n" + "<\/script>\r\n" +
                      "<!-- convertResponseBodyToText -->\r\n" +
                      "<script>\r\n" +
                      "let convertResponseBodyToText = function (binary) {\r\n" +
                      "   let byteMapping = {};\r\n" +
                      "   for ( let i = 0; i < 256; i++ ) {\r\n" +
                      "       for ( let j = 0; j < 256; j++ ) {\r\n" +
                      "           byteMapping[ String.fromCharCode( i + j * 256 ) ] =\r\n" +
                      "           String.fromCharCode(i) + String.fromCharCode(j);\r\n" +
                      "       }\r\n" +
                      "   }\r\n" +
                      "   let rawBytes = IEBinaryToArray_ByteStr(binary);\r\n" +
                      "   let lastChr = IEBinaryToArray_ByteStr_Last(binary);\r\n" +
                      "   return rawBytes.replace(/[\\s\\S]/g," +
                      "                           function( match ) { return byteMapping[match]; }) + lastChr;\r\n" +
                      "};\r\n" +
                      "<\/script>\r\n";
                  document.write(IEBinaryToArray_ByteStr_Script);
              }
          };
          return WebCapability;
      }());
      wxgame.WebCapability = WebCapability;
      __reflect(WebCapability.prototype, "egret.wxgame.WebCapability");
      WebCapability.detect();
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebExternalInterface = (function () {
          function WebExternalInterface() {
          }
          /**
           * @private
           * @param functionName
           * @param value
           */
          WebExternalInterface.call = function (functionName, value) {
          };
          /**
           * @private
           * @param functionName
           * @param listener
           */
          WebExternalInterface.addCallback = function (functionName, listener) {
          };
          return WebExternalInterface;
      }());
      wxgame.WebExternalInterface = WebExternalInterface;
      __reflect(WebExternalInterface.prototype, "egret.wxgame.WebExternalInterface", ["egret.ExternalInterface"]);
      var ua = navigator.userAgent.toLowerCase();
      if (ua.indexOf("egretnative") < 0) {
          egret.ExternalInterface = WebExternalInterface;
      }
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
(function (egret) {
  var wxgame;
  (function (wxgame) {
      var callBackDic = {};
      /**
       * @private
       */
      var NativeExternalInterface = (function () {
          function NativeExternalInterface() {
          }
          NativeExternalInterface.call = function (functionName, value) {
              var data = {};
              data.functionName = functionName;
              data.value = value;
              egret_native.sendInfoToPlugin(JSON.stringify(data));
          };
          NativeExternalInterface.addCallback = function (functionName, listener) {
              callBackDic[functionName] = listener;
          };
          return NativeExternalInterface;
      }());
      wxgame.NativeExternalInterface = NativeExternalInterface;
      __reflect(NativeExternalInterface.prototype, "egret.wxgame.NativeExternalInterface", ["egret.ExternalInterface"]);
      /**
       * @private
       * @param info
       */
      function onReceivedPluginInfo(info) {
          var data = JSON.parse(info);
          var functionName = data.functionName;
          var listener = callBackDic[functionName];
          if (listener) {
              var value = data.value;
              listener.call(null, value);
          }
          else {
              egret.$warn(1050, functionName);
          }
      }
      var ua = navigator.userAgent.toLowerCase();
      if (ua.indexOf("egretnative") >= 0) {
          egret.ExternalInterface = NativeExternalInterface;
          egret_native.receivedPluginInfo = onReceivedPluginInfo;
      }
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      function getOption(key) {
          var launchOptions = wx.getLaunchOptionsSync();
          return launchOptions.query[key] || launchOptions[key];
      }
      wxgame.getOption = getOption;
      egret.getOption = getOption;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebPlayer = (function (_super) {
          __extends(WebPlayer, _super);
          function WebPlayer(container, options) {
              var _this = _super.call(this) || this;
              _this.init(container, options);
              _this.initOrientation();
              return _this;
          }
          WebPlayer.prototype.init = function (container, options) {
              var option = this.readOption(container, options);
              var stage = new egret.Stage();
              stage.$screen = this;
              stage.$scaleMode = option.scaleMode;
              stage.$orientation = option.orientation;
              stage.$maxTouches = option.maxTouches;
              stage.frameRate = option.frameRate;
              stage.textureScaleFactor = option.textureScaleFactor;
              var buffer = new egret.sys.RenderBuffer(undefined, undefined, true);
              var canvas = buffer.surface;
              this.attachCanvas(container, canvas);
              var webTouch = new wxgame.WebTouchHandler(stage, canvas);
              var player = new egret.sys.Player(buffer, stage, option.entryClassName);
              egret.lifecycle.stage = stage;
              egret.lifecycle.addLifecycleListener(wxgame.WebLifeCycleHandler);
              if (option.showFPS || option.showLog) {
                  player.displayFPS(option.showFPS, option.showLog, option.logFilter, option.fpsStyles);
              }
              this.playerOption = option;
              this.container = container;
              this.canvas = canvas;
              this.stage = stage;
              this.player = player;
              this.webTouchHandler = webTouch;
              this.updateScreenSize();
              this.updateMaxTouches();
              player.start();
          };
          WebPlayer.prototype.initOrientation = function () {
              var self = this;
              window.addEventListener("orientationchange", function () {
                  window.setTimeout(function () {
                      egret.StageOrientationEvent.dispatchStageOrientationEvent(self.stage, egret.StageOrientationEvent.ORIENTATION_CHANGE);
                  }, 350);
              });
          };
          /**
           * 读取初始化参数
           */
          WebPlayer.prototype.readOption = function (container, options) {
              var option = {};
              option.entryClassName = options.entryClassName || "Main";
              option.scaleMode = options.scaleMode || egret.StageScaleMode.FIXED_WIDTH;
              if (option.scaleMode == egret.StageScaleMode.SHOW_ALL) {
                  throw new Error("小游戏不支持 showAll 适配模式，推荐使用 fixedWidth 模式");
              }
              option.frameRate = options.frameRate || 30;
              option.contentWidth = options.contentWidth || 640;
              option.contentHeight = options.contentHeight || 1136;
              option.orientation = options.orientation || egret.OrientationMode.AUTO;
              option.maxTouches = 2;
              option.textureScaleFactor = 1;
              option.showFPS = false;
              var styleStr = "x:0,y:0,size:12,textColor:0xffffff,bgAlpha:0.9";
              var stylesArr = styleStr.split(",");
              var styles = {};
              for (var i = 0; i < stylesArr.length; i++) {
                  var tempStyleArr = stylesArr[i].split(":");
                  styles[tempStyleArr[0]] = tempStyleArr[1];
              }
              option.fpsStyles = styles;
              option.showLog = false;
              option.logFilter = "";
              return option;
          };
          /**
           * @private
           * 添加canvas到container。
           */
          WebPlayer.prototype.attachCanvas = function (container, canvas) {
              var style = canvas.style;
              style.cursor = "inherit";
              style.position = "absolute";
              style.top = "0";
              style.bottom = "0";
              style.left = "0";
              style.right = "0";
              // container.appendChild(canvas);
              // style = container.style;
              // style.overflow = "hidden";
              // style.position = "absolute";
          };
          /**
           * @private
           * 更新播放器视口尺寸
           */
          WebPlayer.prototype.updateScreenSize = function () {
              var canvas = this.canvas;
              if (canvas['userTyping'])
                  return;
              var option = this.playerOption;
              var screenRect = canvas.getBoundingClientRect();
              var top = 0;
              var boundingClientWidth = screenRect.width;
              var boundingClientHeight = screenRect.height;
              if (screenRect.top < 0) {
                  boundingClientHeight += screenRect.top;
                  top = -screenRect.top;
              }
              var shouldRotate = false;
              var orientation = this.stage.$orientation;
              if (orientation != egret.OrientationMode.AUTO) {
                  shouldRotate = orientation != egret.OrientationMode.PORTRAIT && boundingClientHeight > boundingClientWidth
                      || orientation == egret.OrientationMode.PORTRAIT && boundingClientWidth > boundingClientHeight;
              }
              var screenWidth = shouldRotate ? boundingClientHeight : boundingClientWidth;
              var screenHeight = shouldRotate ? boundingClientWidth : boundingClientHeight;
              egret.Capabilities["boundingClientWidth" + ""] = screenWidth;
              egret.Capabilities["boundingClientHeight" + ""] = screenHeight;
              var stageSize = egret.sys.screenAdapter.calculateStageSize(this.stage.$scaleMode, screenWidth, screenHeight, option.contentWidth, option.contentHeight);
              var stageWidth = stageSize.stageWidth;
              var stageHeight = stageSize.stageHeight;
              var displayWidth = stageSize.displayWidth;
              var displayHeight = stageSize.displayHeight;
              canvas.style[wxgame.getPrefixStyleName("transformOrigin")] = "0% 0% 0px";
              if (canvas.width != stageWidth) {
                  if (!wxgame.isSubContext) {
                      if (window["sharedCanvas"]) {
                          window["sharedCanvas"].width = stageWidth;
                      }
                      canvas.width = stageWidth;
                  }
              }
              if (canvas.height != stageHeight) {
                  if (!wxgame.isSubContext) {
                      if (window["sharedCanvas"]) {
                          window["sharedCanvas"].height = stageHeight;
                      }
                      canvas.height = stageHeight;
                  }
              }
              var rotation = 0;
              if (shouldRotate) {
                  if (orientation == egret.OrientationMode.LANDSCAPE) {
                      rotation = 90;
                      canvas.style.top = top + (boundingClientHeight - displayWidth) / 2 + "px";
                      canvas.style.left = (boundingClientWidth + displayHeight) / 2 + "px";
                  }
                  else {
                      rotation = -90;
                      canvas.style.top = top + (boundingClientHeight + displayWidth) / 2 + "px";
                      canvas.style.left = (boundingClientWidth - displayHeight) / 2 + "px";
                  }
              }
              else {
                  canvas.style.top = top + (boundingClientHeight - displayHeight) / 2 + "px";
                  canvas.style.left = (boundingClientWidth - displayWidth) / 2 + "px";
              }
              var scalex = displayWidth / stageWidth, scaley = displayHeight / stageHeight;
              var canvasScaleX = scalex * egret.sys.DisplayList.$canvasScaleFactor;
              var canvasScaleY = scaley * egret.sys.DisplayList.$canvasScaleFactor;
              // if (egret.Capabilities.$renderMode == "canvas") {
              //     canvasScaleX = Math.ceil(canvasScaleX);
              //     canvasScaleY = Math.ceil(canvasScaleY);
              // }
              var m = new egret.Matrix();
              m.scale(scalex / canvasScaleX, scaley / canvasScaleY);
              m.rotate(rotation * Math.PI / 180);
              var transform = "matrix(" + m.a + "," + m.b + "," + m.c + "," + m.d + "," + m.tx + "," + m.ty + ")";
              canvas.style[wxgame.getPrefixStyleName("transform")] = transform;
              egret.sys.DisplayList.$setCanvasScale(canvasScaleX, canvasScaleY);
              this.webTouchHandler.updateScaleMode(scalex, scaley, rotation);
              this.player.updateStageSize(stageWidth, stageHeight); //不要在这个方法后面修改属性
          };
          WebPlayer.prototype.setContentSize = function (width, height) {
              var option = this.playerOption;
              option.contentWidth = width;
              option.contentHeight = height;
              this.updateScreenSize();
          };
          /**
           * @private
           * 更新触摸数量
           */
          WebPlayer.prototype.updateMaxTouches = function () {
              this.webTouchHandler.$updateMaxTouches();
          };
          return WebPlayer;
      }(egret.HashObject));
      wxgame.WebPlayer = WebPlayer;
      __reflect(WebPlayer.prototype, "egret.wxgame.WebPlayer", ["egret.sys.Screen"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      var sharedCanvas;
      var sharedContext;
      /**
       * @private
       */
      function convertImageToCanvas(texture, rect) {
          if (!sharedCanvas) {
              sharedCanvas = document.createElement("canvas");
              sharedContext = sharedCanvas.getContext("2d");
          }
          var w = texture.$getTextureWidth();
          var h = texture.$getTextureHeight();
          if (rect == null) {
              rect = egret.$TempRectangle;
              rect.x = 0;
              rect.y = 0;
              rect.width = w;
              rect.height = h;
          }
          rect.x = Math.min(rect.x, w - 1);
          rect.y = Math.min(rect.y, h - 1);
          rect.width = Math.min(rect.width, w - rect.x);
          rect.height = Math.min(rect.height, h - rect.y);
          var iWidth = Math.floor(rect.width);
          var iHeight = Math.floor(rect.height);
          var surface = sharedCanvas;
          surface["style"]["width"] = iWidth + "px";
          surface["style"]["height"] = iHeight + "px";
          sharedCanvas.width = iWidth;
          sharedCanvas.height = iHeight;
          if (egret.Capabilities.renderMode == "webgl") {
              var renderTexture = void 0;
              //webgl下非RenderTexture纹理先画到RenderTexture
              if (!texture.$renderBuffer) {
                  renderTexture = new egret.RenderTexture();
                  renderTexture.drawToTexture(new egret.Bitmap(texture));
              }
              else {
                  renderTexture = texture;
              }
              //从RenderTexture中读取像素数据，填入canvas
              var pixels = renderTexture.$renderBuffer.getPixels(rect.x, rect.y, iWidth, iHeight);
              var x = 0;
              var y = 0;
              for (var i = 0; i < pixels.length; i += 4) {
                  sharedContext.fillStyle =
                      'rgba(' + pixels[i]
                          + ',' + pixels[i + 1]
                          + ',' + pixels[i + 2]
                          + ',' + (pixels[i + 3] / 255) + ')';
                  sharedContext.fillRect(x, y, 1, 1);
                  x++;
                  if (x == iWidth) {
                      x = 0;
                      y++;
                  }
              }
              if (!texture.$renderBuffer) {
                  renderTexture.dispose();
              }
              return surface;
          }
          else {
              var bitmapData = texture;
              var offsetX = Math.round(bitmapData.$offsetX);
              var offsetY = Math.round(bitmapData.$offsetY);
              var bitmapWidth = bitmapData.$bitmapWidth;
              var bitmapHeight = bitmapData.$bitmapHeight;
              sharedContext.drawImage(bitmapData.$bitmapData.source, bitmapData.$bitmapX + rect.x / egret.$TextureScaleFactor, bitmapData.$bitmapY + rect.y / egret.$TextureScaleFactor, bitmapWidth * rect.width / w, bitmapHeight * rect.height / h, offsetX, offsetY, rect.width, rect.height);
              return surface;
          }
      }
      /**
       * @private
       */
      function toDataURL(type, rect, encoderOptions) {
          try {
              var surface = convertImageToCanvas(this, rect);
              var result = surface.toDataURL(type, encoderOptions);
              return result;
          }
          catch (e) {
              egret.$error(1033);
          }
          return null;
      }
      /**
       * 有些杀毒软件认为 saveToFile 可能是一个病毒文件
       */
      function eliFoTevas(type, filePath, rect, encoderOptions) {
          var surface = convertImageToCanvas(this, rect);
          var result = surface.toTempFilePathSync({
              fileType: type.indexOf("png") >= 0 ? "png" : "jpg"
          });
          wx.getFileSystemManager().saveFile({
              tempFilePath: result,
              filePath: wx.env.USER_DATA_PATH + "/" + filePath,
              success: function (res) {
                  //todo
              }
          });
          return result;
      }
      function getPixel32(x, y) {
          egret.$warn(1041, "getPixel32", "getPixels");
          return this.getPixels(x, y);
      }
      function getPixels(x, y, width, height) {
          if (width === void 0) { width = 1; }
          if (height === void 0) { height = 1; }
          try {
              var surface = convertImageToCanvas(this);
              var result = sharedContext.getImageData(x, y, width, height).data;
              return result;
          }
          catch (e) {
              egret.$error(1039);
          }
      }
      egret.Texture.prototype.toDataURL = toDataURL;
      egret.Texture.prototype.saveToFile = eliFoTevas;
      egret.Texture.prototype.getPixel32 = getPixel32;
      egret.Texture.prototype.getPixels = getPixels;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * XML节点基类
       */
      var XMLNode = (function () {
          /**
           * @private
           */
          function XMLNode(nodeType, parent) {
              this.nodeType = nodeType;
              this.parent = parent;
          }
          return XMLNode;
      }());
      wxgame.XMLNode = XMLNode;
      __reflect(XMLNode.prototype, "egret.wxgame.XMLNode");
      /**
       * @private
       * XML节点对象
       */
      var XML = (function (_super) {
          __extends(XML, _super);
          /**
           * @private
           */
          function XML(localName, parent, prefix, namespace, name) {
              var _this = _super.call(this, 1, parent) || this;
              /**
               * @private
               * 当前节点上的属性列表
               */
              _this.attributes = {};
              /**
               * @private
               * 当前节点的子节点列表
               */
              _this.children = [];
              _this.localName = localName;
              _this.prefix = prefix;
              _this.namespace = namespace;
              _this.name = name;
              return _this;
          }
          return XML;
      }(XMLNode));
      wxgame.XML = XML;
      __reflect(XML.prototype, "egret.wxgame.XML");
      /**
       * @private
       * XML文本节点
       */
      var XMLText = (function (_super) {
          __extends(XMLText, _super);
          /**
           * @private
           */
          function XMLText(text, parent) {
              var _this = _super.call(this, 3, parent) || this;
              _this.text = text;
              return _this;
          }
          return XMLText;
      }(XMLNode));
      wxgame.XMLText = XMLText;
      __reflect(XMLText.prototype, "egret.wxgame.XMLText");
      var parser;
      /**
       * @private
       * 解析字符串为XML对象
       * @param text 要解析的字符串
       */
      function parse(text) {
          if (!parser) {
              if (!window["DOMParser"]) {
                  console.error("没有 XML 支持库，请访问 http://developer.egret.com/cn/github/egret-docs/Engine2D/minigame/minigameFAQ/index.html#xml 了解详情");
              }
              else {
                  parser = new DOMParser();
              }
          }
          var xmlDoc = parser.parseFromString(text, "text/xml");
          var length = xmlDoc.childNodes.length;
          for (var i = 0; i < length; i++) {
              var node = xmlDoc.childNodes[i];
              if (node.nodeType == 1) {
                  return parseNode(node, null);
              }
          }
          return null;
      }
      /**
       * @private
       * 解析一个节点
       */
      function parseNode(node, parent) {
          if (node.localName == "parsererror") {
              throw new Error(node.textContent);
          }
          var xml = new XML(node.localName, parent, node["prefix"], node.namespaceURI, node.nodeName);
          var nodeAttributes = node.attributes;
          var attributes = xml.attributes;
          var length = nodeAttributes.length;
          for (var i = 0; i < length; i++) {
              var attributeNode = nodeAttributes[i];
              var name_1 = attributeNode.name;
              if (name_1.indexOf("xmlns:") == 0) {
                  continue;
              }
              attributes[name_1] = attributeNode.value;
              xml["$" + name_1] = attributeNode.value;
          }
          var childNodes = node.childNodes;
          length = childNodes.length;
          var children = xml.children;
          for (var i = 0; i < length; i++) {
              var childNode = childNodes[i];
              var nodeType = childNode.nodeType;
              var childXML = null;
              if (nodeType == 1) {
                  childXML = parseNode(childNode, xml);
              }
              else if (nodeType == 3) {
                  var text = childNode.textContent.trim();
                  if (text) {
                      childXML = new XMLText(text, xml);
                  }
              }
              if (childXML) {
                  children.push(childXML);
              }
          }
          return xml;
      }
      egret.XML = { parse: parse };
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebDeviceOrientation = (function (_super) {
          __extends(WebDeviceOrientation, _super);
          function WebDeviceOrientation() {
              var _this = _super !== null && _super.apply(this, arguments) || this;
              /**
               * @private
               */
              _this.onChange = function (e) {
                  var event = new egret.OrientationEvent(egret.Event.CHANGE);
                  event.beta = e.beta;
                  event.gamma = e.gamma;
                  event.alpha = e.alpha;
                  _this.dispatchEvent(event);
              };
              return _this;
          }
          /**
           * @private
           *
           */
          WebDeviceOrientation.prototype.start = function () {
              window.addEventListener("deviceorientation", this.onChange);
          };
          /**
           * @private
           *
           */
          WebDeviceOrientation.prototype.stop = function () {
              window.removeEventListener("deviceorientation", this.onChange);
          };
          return WebDeviceOrientation;
      }(egret.EventDispatcher));
      wxgame.WebDeviceOrientation = WebDeviceOrientation;
      __reflect(WebDeviceOrientation.prototype, "egret.wxgame.WebDeviceOrientation", ["egret.DeviceOrientation"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
egret.DeviceOrientation = egret.wxgame.WebDeviceOrientation;

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebGeolocation = (function (_super) {
          __extends(WebGeolocation, _super);
          /**
           * @private
           */
          function WebGeolocation(option) {
              var _this = _super.call(this) || this;
              /**
               * @private
               */
              _this.onUpdate = function (position) {
                  var event = new egret.GeolocationEvent(egret.Event.CHANGE);
                  var coords = position.coords;
                  event.altitude = coords.altitude;
                  event.heading = coords.heading;
                  event.accuracy = coords.accuracy;
                  event.latitude = coords.latitude;
                  event.longitude = coords.longitude;
                  event.speed = coords.speed;
                  event.altitudeAccuracy = coords.altitudeAccuracy;
                  _this.dispatchEvent(event);
              };
              /**
               * @private
               */
              _this.onError = function (error) {
                  var errorType = egret.GeolocationEvent.UNAVAILABLE;
                  if (error.code == error.PERMISSION_DENIED)
                      errorType = egret.GeolocationEvent.PERMISSION_DENIED;
                  var event = new egret.GeolocationEvent(egret.IOErrorEvent.IO_ERROR);
                  event.errorType = errorType;
                  event.errorMessage = error.message;
                  _this.dispatchEvent(event);
              };
              _this.geolocation = navigator.geolocation;
              return _this;
          }
          /**
           * @private
           *
           */
          WebGeolocation.prototype.start = function () {
              var geo = this.geolocation;
              if (geo)
                  this.watchId = geo.watchPosition(this.onUpdate, this.onError);
              else
                  this.onError({
                      code: 2,
                      message: egret.sys.tr(3004),
                      PERMISSION_DENIED: 1,
                      POSITION_UNAVAILABLE: 2
                  });
          };
          /**
           * @private
           *
           */
          WebGeolocation.prototype.stop = function () {
              var geo = this.geolocation;
              geo.clearWatch(this.watchId);
          };
          return WebGeolocation;
      }(egret.EventDispatcher));
      wxgame.WebGeolocation = WebGeolocation;
      __reflect(WebGeolocation.prototype, "egret.wxgame.WebGeolocation", ["egret.Geolocation"]);
      egret.Geolocation = egret.wxgame.WebGeolocation;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WebMotion = (function (_super) {
          __extends(WebMotion, _super);
          function WebMotion() {
              var _this = _super !== null && _super.apply(this, arguments) || this;
              /**
               * @private
               */
              _this.onChange = function (e) {
                  var event = new egret.MotionEvent(egret.Event.CHANGE);
                  var acceleration = {
                      x: e.acceleration.x,
                      y: e.acceleration.y,
                      z: e.acceleration.z
                  };
                  var accelerationIncludingGravity = {
                      x: e.accelerationIncludingGravity.x,
                      y: e.accelerationIncludingGravity.y,
                      z: e.accelerationIncludingGravity.z
                  };
                  var rotation = {
                      alpha: e.rotationRate.alpha,
                      beta: e.rotationRate.beta,
                      gamma: e.rotationRate.gamma
                  };
                  event.acceleration = acceleration;
                  event.accelerationIncludingGravity = accelerationIncludingGravity;
                  event.rotationRate = rotation;
                  _this.dispatchEvent(event);
              };
              return _this;
          }
          /**
           * @private
           *
           */
          WebMotion.prototype.start = function () {
              window.addEventListener("devicemotion", this.onChange);
          };
          /**
           * @private
           *
           */
          WebMotion.prototype.stop = function () {
              window.removeEventListener("devicemotion", this.onChange);
          };
          return WebMotion;
      }(egret.EventDispatcher));
      wxgame.WebMotion = WebMotion;
      __reflect(WebMotion.prototype, "egret.wxgame.WebMotion", ["egret.Motion"]);
      egret.Motion = egret.wxgame.WebMotion;
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      if (true) {
          var logFuncs_1;
          function setLogLevel(logType) {
              if (logFuncs_1 == null) {
                  logFuncs_1 = {
                      "error": console.error,
                      "debug": console.debug,
                      "warn": console.warn,
                      "info": console.info,
                      "log": console.log
                  };
              }
              switch (logType) {
                  case egret.Logger.OFF:
                      console.error = function () {
                      };
                  case egret.Logger.ERROR:
                      console.warn = function () {
                      };
                  case egret.Logger.WARN:
                      console.info = function () {
                      };
                      console.log = function () {
                      };
                  case egret.Logger.INFO:
                      console.debug = function () {
                      };
                  default:
                      break;
              }
              switch (logType) {
                  case egret.Logger.ALL:
                  case egret.Logger.DEBUG:
                      console.debug = logFuncs_1["debug"];
                  case egret.Logger.INFO:
                      console.log = logFuncs_1["log"];
                      console.info = logFuncs_1["info"];
                  case egret.Logger.WARN:
                      console.warn = logFuncs_1["warn"];
                  case egret.Logger.ERROR:
                      console.error = logFuncs_1["error"];
                  default:
                      break;
              }
          }
          Object.defineProperty(egret.Logger, "logLevel", {
              set: setLogLevel,
              enumerable: true,
              configurable: true
          });
      }
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * 绘制指令管理器
       * 用来维护drawData数组
       */
      var WebGLDrawCmdManager = (function () {
          function WebGLDrawCmdManager() {
              /**
               * 用于缓存绘制命令的数组
               */
              this.drawData = {};
              this.drawDataLen = 0;
          }
          /**
           * 压入绘制texture指令
           */
          WebGLDrawCmdManager.prototype.pushDrawTexture = function (texture, count, filter, textureWidth, textureHeight) {
              if (count === void 0) { count = 2; }
              if (filter) {
                  //根据filter压入切换program
                  var programeKey = filter.type;
                  if (this.lastProgramKey !== programeKey) {
                      this.pushChangeProgram(programeKey, filter);
                  }
                  // 目前有滤镜的情况下不会合并绘制
                  var data = this.drawData[this.drawDataLen] || {};
                  data.type = 0 /* TEXTURE */;
                  data.texture = texture;
                  data.count = count;
                  data.textureWidth = textureWidth;
                  data.textureHeight = textureHeight;
                  data.filter = filter;
                  this.drawData[this.drawDataLen] = data;
                  this.drawDataLen++;
                  this.lastDrawTextureData = null;
              }
              else {
                  if (this.lastDrawTextureData == null || texture != this.lastDrawTextureData.texture) {
                      if (this.lastProgramKey !== "texture") {
                          this.pushChangeProgram("texture");
                      }
                      var data = this.drawData[this.drawDataLen] || {};
                      data.type = 0 /* TEXTURE */;
                      data.texture = texture;
                      data.count = 0;
                      this.drawData[this.drawDataLen] = data;
                      this.drawDataLen++;
                      this.lastDrawTextureData = data;
                  }
                  this.drawData[this.drawDataLen - 1].count += count;
              }
          };
          WebGLDrawCmdManager.prototype.pushChangeSmoothing = function (texture, smoothing) {
              texture["smoothing"] = smoothing;
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 9 /* SMOOTHING */;
              data.texture = texture;
              data.smoothing = smoothing;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /**
           * 压入pushMask指令
           */
          WebGLDrawCmdManager.prototype.pushPushMask = function (count) {
              if (count === void 0) { count = 1; }
              if (this.lastProgramKey !== "primitive") {
                  this.pushChangeProgram("primitive");
              }
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 1 /* PUSH_MASK */;
              data.count = count * 2;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /**
           * 压入popMask指令
           */
          WebGLDrawCmdManager.prototype.pushPopMask = function (count) {
              if (count === void 0) { count = 1; }
              if (this.lastProgramKey !== "primitive") {
                  this.pushChangeProgram("primitive");
              }
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 2 /* POP_MASK */;
              data.count = count * 2;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /**
           * 压入混色指令
           */
          WebGLDrawCmdManager.prototype.pushSetBlend = function (value) {
              var len = this.drawDataLen;
              // 有无遍历到有效绘图操作
              var drawState = false;
              for (var i = len - 1; i >= 0; i--) {
                  var data = this.drawData[i];
                  if (data) {
                      if (data.type == 0 /* TEXTURE */) {
                          drawState = true;
                      }
                      // 如果与上一次blend操作之间无有效绘图，上一次操作无效
                      if (!drawState && data.type == 3 /* BLEND */) {
                          delete this.drawData[i];
                          continue;
                      }
                      // 如果与上一次blend操作重复，本次操作无效
                      if (data.type == 3 /* BLEND */) {
                          if (data.value == value) {
                              return;
                          }
                          else {
                              break;
                          }
                      }
                  }
              }
              var _data = this.drawData[this.drawDataLen] || {};
              _data.type = 3 /* BLEND */;
              _data.value = value;
              this.drawData[this.drawDataLen] = _data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /*
           * 压入resize render target命令
           */
          WebGLDrawCmdManager.prototype.pushResize = function (buffer, width, height) {
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 4 /* RESIZE_TARGET */;
              data.buffer = buffer;
              data.width = width;
              data.height = height;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /*
           * 压入clear color命令
           */
          WebGLDrawCmdManager.prototype.pushClearColor = function () {
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 5 /* CLEAR_COLOR */;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /**
           * 压入激活buffer命令
           */
          WebGLDrawCmdManager.prototype.pushActivateBuffer = function (buffer) {
              var len = this.drawDataLen;
              // 有无遍历到有效绘图操作
              var drawState = false;
              for (var i = len - 1; i >= 0; i--) {
                  var data = this.drawData[i];
                  if (data) {
                      if (data.type != 3 /* BLEND */ && data.type != 6 /* ACT_BUFFER */) {
                          drawState = true;
                      }
                      // 如果与上一次buffer操作之间无有效绘图，上一次操作无效
                      if (!drawState && data.type == 6 /* ACT_BUFFER */) {
                          delete this.drawData[i];
                          continue;
                      }
                      // 如果与上一次buffer操作重复，本次操作无效
                      // if(data.type == DRAWABLE_TYPE.ACT_BUFFER) {
                      //     if(data.buffer == buffer) {
                      //         return;
                      //     } else {
                      //         break;
                      //     }
                      // }
                  }
              }
              var _data = this.drawData[this.drawDataLen] || {};
              _data.type = 6 /* ACT_BUFFER */;
              _data.buffer = buffer;
              _data.width = buffer.rootRenderTarget.width;
              _data.height = buffer.rootRenderTarget.height;
              this.drawData[this.drawDataLen] = _data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /*
           * 压入enabel scissor命令
           */
          WebGLDrawCmdManager.prototype.pushEnableScissor = function (x, y, width, height) {
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 7 /* ENABLE_SCISSOR */;
              data.x = x;
              data.y = y;
              data.width = width;
              data.height = height;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /*
           * 压入disable scissor命令
           */
          WebGLDrawCmdManager.prototype.pushDisableScissor = function () {
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 8 /* DISABLE_SCISSOR */;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          /**
           * 清空命令数组
           */
          WebGLDrawCmdManager.prototype.clear = function () {
              for (var i = 0; i < this.drawDataLen; i++) {
                  var data = this.drawData[i];
                  if (!data)
                      continue;
                  data.type = 0;
                  data.count = 0;
                  data.texture = null;
                  data.filter = null;
                  data.uv = null;
                  data.value = "";
                  data.buffer = null;
                  data.width = 0;
                  data.height = 0;
                  data.vertSource = null;
                  data.fragSource = null;
                  data.key = null;
              }
              this.drawDataLen = 0;
              this.lastDrawTextureData = null;
              this.lastProgramKey = null;
          };
          /**
           * 压入切换shader programe命令
           */
          WebGLDrawCmdManager.prototype.pushChangeProgram = function (type, filter) {
              var key;
              var vertSource = wxgame.EgretShaderLib.default_vert;
              var fragSource = wxgame.EgretShaderLib.blur_frag;
              if (type === "texture") {
                  key = "texture";
                  fragSource = wxgame.EgretShaderLib.texture_frag;
              }
              else if (type === "custom") {
                  key = filter.$shaderKey;
                  vertSource = filter.$vertexSrc;
                  fragSource = filter.$fragmentSrc;
              }
              else if (type === "colorTransform") {
                  key = "colorTransform";
                  fragSource = wxgame.EgretShaderLib.colorTransform_frag;
              }
              else if (type === "blurX" || type === "blurY") {
                  key = "blur";
              }
              else if (type === "glow") {
                  key = "glow";
                  fragSource = wxgame.EgretShaderLib.glow_frag;
              }
              else if (type === "primitive") {
                  key = "primitive";
                  fragSource = wxgame.EgretShaderLib.primitive_frag;
                  vertSource = wxgame.EgretShaderLib.default_vert;
              }
              //记录上一次的Programe类型
              this.lastProgramKey = key;
              var data = this.drawData[this.drawDataLen] || {};
              data.type = 10 /* CHANGE_PROGRAM */;
              data.key = key;
              data.vertSource = vertSource;
              data.fragSource = fragSource;
              this.drawData[this.drawDataLen] = data;
              this.drawDataLen++;
              this.lastDrawTextureData = null;
          };
          return WebGLDrawCmdManager;
      }());
      wxgame.WebGLDrawCmdManager = WebGLDrawCmdManager;
      __reflect(WebGLDrawCmdManager.prototype, "egret.wxgame.WebGLDrawCmdManager");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * 顶点数组管理对象
       * 用来维护顶点数组
       */
      var WebGLVertexArrayObject = (function () {
          function WebGLVertexArrayObject() {
              this.size = 2000;
              this.vertexMaxSize = this.size * 4;
              this.indicesMaxSize = this.size * 6;
              this.vertSize = 4;
              this.vertexIndex = 0;
              this.indexIndex = 0;
              this.hasMesh = false;
              var numVerts = this.vertexMaxSize * this.vertSize;
              var numIndices = this.indicesMaxSize;
              var buffer = new ArrayBuffer(numVerts * 4);
              this.float32Array = new Float32Array(buffer);
              this.uint32Array = new Uint32Array(buffer);
              this.indices = new Uint16Array(numIndices);
              this.indicesForMesh = new Uint16Array(numIndices);
              for (var i = 0, j = 0; i < numIndices; i += 6, j += 4) {
                  this.indices[i + 0] = j + 0;
                  this.indices[i + 1] = j + 1;
                  this.indices[i + 2] = j + 2;
                  this.indices[i + 3] = j + 0;
                  this.indices[i + 4] = j + 2;
                  this.indices[i + 5] = j + 3;
              }
              //用于drawImageByRenderNode 计算
              this.vertexActualSize = this.vertexMaxSize - 4;
          }
          /**
           * 是否达到最大缓存数量
           */
          WebGLVertexArrayObject.prototype.reachMaxSize = function (vertexCount, indexCount) {
              if (vertexCount === void 0) { vertexCount = 4; }
              if (indexCount === void 0) { indexCount = 6; }
              return this.vertexIndex > this.vertexMaxSize - vertexCount || this.indexIndex > this.indicesMaxSize - indexCount;
          };
          WebGLVertexArrayObject.prototype.reachVertexMaxSize = function () {
              return this.vertexIndex > this.vertexActualSize;
          };
          /**
           * 获取缓存完成的顶点数组
           */
          WebGLVertexArrayObject.prototype.getVertices = function () {
              var view = this.float32Array;
              return view;
          };
          /**
           * 获取缓存完成的索引数组
           */
          WebGLVertexArrayObject.prototype.getIndices = function () {
              return this.indices;
          };
          /**
           * 获取缓存完成的mesh索引数组
           */
          WebGLVertexArrayObject.prototype.getMeshIndices = function () {
              return this.indicesForMesh;
          };
          /**
           * 切换成mesh索引缓存方式
           */
          WebGLVertexArrayObject.prototype.changeToMeshIndices = function () {
              if (!this.hasMesh) {
                  // 拷贝默认index信息到for mesh中
                  for (var i = 0, l = this.indexIndex; i < l; ++i) {
                      this.indicesForMesh[i] = this.indices[i];
                  }
                  this.hasMesh = true;
              }
          };
          WebGLVertexArrayObject.prototype.isMesh = function () {
              return this.hasMesh;
          };
          /**
           * 默认构成矩形
           */
          // private defaultMeshVertices = [0, 0, 1, 0, 1, 1, 0, 1];
          // private defaultMeshUvs = [
          //     0, 0,
          //     1, 0,
          //     1, 1,
          //     0, 1
          // ];
          // private defaultMeshIndices = [0, 1, 2, 0, 2, 3];
          /**
           * 缓存一组顶点
           */
          WebGLVertexArrayObject.prototype.cacheArrays = function (buffer, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, textureSourceWidth, textureSourceHeight, meshUVs, meshVertices, meshIndices, rotated) {
              var alpha = buffer.globalAlpha;
              //计算出绘制矩阵，之后把矩阵还原回之前的
              var locWorldTransform = buffer.globalMatrix;
              var a = locWorldTransform.a;
              var b = locWorldTransform.b;
              var c = locWorldTransform.c;
              var d = locWorldTransform.d;
              var tx = locWorldTransform.tx;
              var ty = locWorldTransform.ty;
              var offsetX = buffer.$offsetX;
              var offsetY = buffer.$offsetY;
              if (offsetX != 0 || offsetY != 0) {
                  tx = offsetX * a + offsetY * c + tx;
                  ty = offsetX * b + offsetY * d + ty;
              }
              if (!meshVertices) {
                  if (destX != 0 || destY != 0) {
                      tx = destX * a + destY * c + tx;
                      ty = destX * b + destY * d + ty;
                  }
                  var a1 = destWidth / sourceWidth;
                  if (a1 != 1) {
                      a = a1 * a;
                      b = a1 * b;
                  }
                  var d1 = destHeight / sourceHeight;
                  if (d1 != 1) {
                      c = d1 * c;
                      d = d1 * d;
                  }
              }
              if (meshVertices) {
                  // 计算索引位置与赋值
                  var float32Array = this.float32Array;
                  var uint32Array = this.uint32Array;
                  var index = this.vertexIndex * this.vertSize;
                  // 缓存顶点数组
                  var i = 0, iD = 0, l = 0;
                  var u = 0, v = 0, x = 0, y = 0;
                  for (i = 0, l = meshUVs.length; i < l; i += 2) {
                      iD = index + i * 5 / 2;
                      x = meshVertices[i];
                      y = meshVertices[i + 1];
                      u = meshUVs[i];
                      v = meshUVs[i + 1];
                      // xy
                      float32Array[iD + 0] = a * x + c * y + tx;
                      float32Array[iD + 1] = b * x + d * y + ty;
                      // uv
                      if (rotated) {
                          uint32Array[iD + 2] = (((sourceY + u * sourceWidth) / textureSourceHeight * 65535) << 16) | ((sourceX + (1.0 - v) * sourceHeight) / textureSourceWidth * 65535);
                      }
                      else {
                          uint32Array[iD + 2] = (((sourceY + v * sourceHeight) / textureSourceHeight * 65535) << 16) | ((sourceX + u * sourceWidth) / textureSourceWidth * 65535);
                      }
                      // alpha
                      float32Array[iD + 3] = alpha;
                  }
                  // 缓存索引数组
                  if (this.hasMesh) {
                      for (var i_1 = 0, l_1 = meshIndices.length; i_1 < l_1; ++i_1) {
                          this.indicesForMesh[this.indexIndex + i_1] = meshIndices[i_1] + this.vertexIndex;
                      }
                  }
                  this.vertexIndex += meshUVs.length / 2;
                  this.indexIndex += meshIndices.length;
              }
              else {
                  var width = textureSourceWidth;
                  var height = textureSourceHeight;
                  var w = sourceWidth;
                  var h = sourceHeight;
                  sourceX = sourceX / width;
                  sourceY = sourceY / height;
                  var float32Array = this.float32Array;
                  var uint32Array = this.uint32Array;
                  var index = this.vertexIndex * this.vertSize;
                  if (rotated) {
                      var temp = sourceWidth;
                      sourceWidth = sourceHeight / width;
                      sourceHeight = temp / height;
                      // xy
                      float32Array[index++] = tx;
                      float32Array[index++] = ty;
                      // uv
                      uint32Array[index++] = ((sourceY * 65535) << 16) | ((sourceWidth + sourceX) * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = a * w + tx;
                      float32Array[index++] = b * w + ty;
                      // uv
                      uint32Array[index++] = (((sourceHeight + sourceY) * 65535) << 16) | ((sourceWidth + sourceX) * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = a * w + c * h + tx;
                      float32Array[index++] = d * h + b * w + ty;
                      // uv
                      uint32Array[index++] = (((sourceHeight + sourceY) * 65535) << 16) | (sourceX * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = c * h + tx;
                      float32Array[index++] = d * h + ty;
                      // uv
                      uint32Array[index++] = ((sourceY * 65535) << 16) | (sourceX * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                  }
                  else {
                      sourceWidth = sourceWidth / width;
                      sourceHeight = sourceHeight / height;
                      // xy
                      float32Array[index++] = tx;
                      float32Array[index++] = ty;
                      // uv
                      uint32Array[index++] = ((sourceY * 65535) << 16) | (sourceX * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = a * w + tx;
                      float32Array[index++] = b * w + ty;
                      // uv
                      uint32Array[index++] = ((sourceY * 65535) << 16) | ((sourceWidth + sourceX) * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = a * w + c * h + tx;
                      float32Array[index++] = d * h + b * w + ty;
                      // uv
                      uint32Array[index++] = (((sourceHeight + sourceY) * 65535) << 16) | ((sourceWidth + sourceX) * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                      // xy
                      float32Array[index++] = c * h + tx;
                      float32Array[index++] = d * h + ty;
                      // uv
                      uint32Array[index++] = (((sourceHeight + sourceY) * 65535) << 16) | (sourceX * 65535);
                      // alpha
                      float32Array[index++] = alpha;
                  }
                  // 缓存索引数组
                  if (this.hasMesh) {
                      var indicesForMesh = this.indicesForMesh;
                      indicesForMesh[this.indexIndex + 0] = 0 + this.vertexIndex;
                      indicesForMesh[this.indexIndex + 1] = 1 + this.vertexIndex;
                      indicesForMesh[this.indexIndex + 2] = 2 + this.vertexIndex;
                      indicesForMesh[this.indexIndex + 3] = 0 + this.vertexIndex;
                      indicesForMesh[this.indexIndex + 4] = 2 + this.vertexIndex;
                      indicesForMesh[this.indexIndex + 5] = 3 + this.vertexIndex;
                  }
                  this.vertexIndex += 4;
                  this.indexIndex += 6;
              }
          };
          WebGLVertexArrayObject.prototype.clear = function () {
              this.hasMesh = false;
              this.vertexIndex = 0;
              this.indexIndex = 0;
          };
          return WebGLVertexArrayObject;
      }());
      wxgame.WebGLVertexArrayObject = WebGLVertexArrayObject;
      __reflect(WebGLVertexArrayObject.prototype, "egret.wxgame.WebGLVertexArrayObject");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * WebGLRenderTarget类
       * 一个WebGL渲染目标，拥有一个frame buffer和texture
       */
      var WebGLRenderTarget = (function (_super) {
          __extends(WebGLRenderTarget, _super);
          function WebGLRenderTarget(gl, width, height) {
              var _this = _super.call(this) || this;
              // 清除色
              _this.clearColor = [0, 0, 0, 0];
              // 是否启用frame buffer, 默认为true
              _this.useFrameBuffer = true;
              _this.gl = gl;
              // 如果尺寸为 0 chrome会报警
              _this.width = width || 1;
              _this.height = height || 1;
              return _this;
          }
          /**
           * 重置render target的尺寸
           */
          WebGLRenderTarget.prototype.resize = function (width, height) {
              var gl = this.gl;
              this.width = width;
              this.height = height;
              if (this.frameBuffer) {
                  // 设置texture尺寸
                  gl.bindTexture(gl.TEXTURE_2D, this.texture);
                  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
                  // gl.bindTexture(gl.TEXTURE_2D, null);
              }
              if (this.stencilBuffer) {
                  gl.deleteRenderbuffer(this.stencilBuffer);
                  this.stencilBuffer = null;
              }
          };
          /**
           * 激活此render target
           */
          WebGLRenderTarget.prototype.activate = function () {
              var gl = this.gl;
              gl.bindFramebuffer(gl.FRAMEBUFFER, this.getFrameBuffer());
          };
          /**
           * 获取frame buffer
           */
          WebGLRenderTarget.prototype.getFrameBuffer = function () {
              if (!this.useFrameBuffer) {
                  return null;
              }
              return this.frameBuffer;
          };
          WebGLRenderTarget.prototype.initFrameBuffer = function () {
              if (!this.frameBuffer) {
                  var gl = this.gl;
                  // 创建材质
                  this.texture = this.createTexture();
                  // 创建frame buffer
                  this.frameBuffer = gl.createFramebuffer();
                  gl.bindFramebuffer(gl.FRAMEBUFFER, this.frameBuffer);
                  // 绑定材质
                  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.texture, 0);
              }
          };
          /**
           * 创建材质
           * TODO 创建材质的方法可以合并
           */
          WebGLRenderTarget.prototype.createTexture = function () {
              var gl = this.gl;
              var texture = gl.createTexture();
              texture["glContext"] = gl;
              gl.bindTexture(gl.TEXTURE_2D, texture);
              gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, this.width, this.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
              return texture;
          };
          /**
           * 清除render target颜色缓存
           */
          WebGLRenderTarget.prototype.clear = function (bind) {
              var gl = this.gl;
              if (bind) {
                  this.activate();
              }
              gl.colorMask(true, true, true, true);
              gl.clearColor(this.clearColor[0], this.clearColor[1], this.clearColor[2], this.clearColor[3]);
              gl.clear(gl.COLOR_BUFFER_BIT);
          };
          WebGLRenderTarget.prototype.enabledStencil = function () {
              if (!this.frameBuffer || this.stencilBuffer) {
                  return;
              }
              var gl = this.gl;
              // 设置render buffer的尺寸
              gl.bindFramebuffer(gl.FRAMEBUFFER, this.frameBuffer); // 是否需要强制绑定？
              // 绑定stencil buffer
              this.stencilBuffer = gl.createRenderbuffer();
              gl.bindRenderbuffer(gl.RENDERBUFFER, this.stencilBuffer);
              gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, this.width, this.height);
              gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, this.stencilBuffer);
              // 此处不解绑是否会造成bug？
              // gl.bindFramebuffer(gl.FRAMEBUFFER, null);
          };
          WebGLRenderTarget.prototype.dispose = function () {
              egret.WebGLUtils.deleteWebGLTexture(this.texture);
          };
          return WebGLRenderTarget;
      }(egret.HashObject));
      wxgame.WebGLRenderTarget = WebGLRenderTarget;
      __reflect(WebGLRenderTarget.prototype, "egret.wxgame.WebGLRenderTarget");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * WebGL上下文对象，提供简单的绘图接口
       * 抽象出此类，以实现共用一个context
       */
      var WebGLRenderContext = (function () {
          function WebGLRenderContext(width, height) {
              this.glID = null;
              this.projectionX = NaN;
              this.projectionY = NaN;
              this.contextLost = false;
              this.$scissorState = false;
              this.surface = window['canvas'];
              if (egret.nativeRender) {
                  return;
              }
              this.initWebGL();
              this.$bufferStack = [];
              var gl = this.context;
              this.vertexBuffer = gl.createBuffer();
              this.indexBuffer = gl.createBuffer();
              gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
              gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
              this.drawCmdManager = new wxgame.WebGLDrawCmdManager();
              this.vao = new wxgame.WebGLVertexArrayObject();
              this.setGlobalCompositeOperation("source-over");
              this.firstTimeUploadVertices = true;
          }
          WebGLRenderContext.getInstance = function (width, height) {
              if (this.instance) {
                  return this.instance;
              }
              this.instance = new WebGLRenderContext(width, height);
              return this.instance;
          };
          /**
           * 推入一个RenderBuffer并绑定
           */
          WebGLRenderContext.prototype.pushBuffer = function (buffer) {
              this.$bufferStack.push(buffer);
              if (buffer != this.currentBuffer) {
                  if (this.currentBuffer) {
                      // this.$drawWebGL();
                  }
                  this.drawCmdManager.pushActivateBuffer(buffer);
              }
              this.currentBuffer = buffer;
          };
          /**
           * 推出一个RenderBuffer并绑定上一个RenderBuffer
           */
          WebGLRenderContext.prototype.popBuffer = function () {
              // 如果只剩下一个buffer，则不执行pop操作
              // 保证舞台buffer永远在最开始
              if (this.$bufferStack.length <= 1) {
                  return;
              }
              var buffer = this.$bufferStack.pop();
              var lastBuffer = this.$bufferStack[this.$bufferStack.length - 1];
              // 重新绑定
              if (buffer != lastBuffer) {
                  // this.$drawWebGL();
                  this.drawCmdManager.pushActivateBuffer(lastBuffer);
              }
              this.currentBuffer = lastBuffer;
          };
          /**
           * 启用RenderBuffer
           */
          WebGLRenderContext.prototype.activateBuffer = function (buffer) {
              buffer.rootRenderTarget.activate();
              if (!this.bindIndices) {
                  this.uploadIndicesArray(this.vao.getIndices());
              }
              buffer.restoreStencil();
              buffer.restoreScissor();
              this.onResize(buffer.width, buffer.height);
          };
          /**
           * 上传顶点数据
           */
          WebGLRenderContext.prototype.uploadVerticesArray = function (array) {
              var gl = this.context;
              if (this.firstTimeUploadVertices) {
                  gl.bufferData(gl.ARRAY_BUFFER, array, gl.DYNAMIC_DRAW);
                  this.firstTimeUploadVertices = false;
              }
              else {
                  gl.bufferSubData(gl.ARRAY_BUFFER, 0, array);
              }
          };
          /**
           * 上传索引数据
           */
          WebGLRenderContext.prototype.uploadIndicesArray = function (array) {
              var gl = this.context;
              gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, array, gl.STATIC_DRAW);
              this.bindIndices = true;
          };
          /**
           * 销毁绘制对象
           */
          WebGLRenderContext.prototype.destroy = function () {
              this.surface.width = this.surface.height = 0;
          };
          WebGLRenderContext.prototype.onResize = function (width, height) {
              width = width || this.surface.width;
              height = height || this.surface.height;
              this.projectionX = width / 2;
              this.projectionY = -height / 2;
              if (this.context) {
                  this.context.viewport(0, 0, width, height);
              }
          };
          /**
           * 改变渲染缓冲的大小并清空缓冲区
           * @param width 改变后的宽
           * @param height 改变后的高
           * @param useMaxSize 若传入true，则将改变后的尺寸与已有尺寸对比，保留较大的尺寸。
           */
          WebGLRenderContext.prototype.resize = function (width, height, useMaxSize) {
              var surface = this.surface;
              if (useMaxSize) {
                  if (surface.width < width) {
                      surface.width = width;
                      if (!wxgame.isSubContext && window["sharedCanvas"]) {
                          window["sharedCanvas"].width = width;
                      }
                  }
                  if (surface.height < height) {
                      surface.height = height;
                      if (!wxgame.isSubContext && window["sharedCanvas"]) {
                          window["sharedCanvas"].height = height;
                      }
                  }
              }
              else {
                  if (surface.width != width) {
                      surface.width = width;
                      if (!wxgame.isSubContext && window["sharedCanvas"]) {
                          window["sharedCanvas"].width = width;
                      }
                  }
                  if (surface.height != height) {
                      surface.height = height;
                      if (!wxgame.isSubContext && window["sharedCanvas"]) {
                          window["sharedCanvas"].height = height;
                      }
                  }
              }
              this.onResize();
          };
          WebGLRenderContext.prototype.initWebGL = function () {
              this.onResize();
              this.surface.addEventListener("webglcontextlost", this.handleContextLost.bind(this), false);
              this.surface.addEventListener("webglcontextrestored", this.handleContextRestored.bind(this), false);
              this.getWebGLContext();
              var gl = this.context;
              this.$maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
          };
          WebGLRenderContext.prototype.handleContextLost = function () {
              this.contextLost = true;
          };
          WebGLRenderContext.prototype.handleContextRestored = function () {
              this.initWebGL();
              this.contextLost = false;
          };
          WebGLRenderContext.prototype.getWebGLContext = function () {
              // let options = {
              //     antialias: WebGLRenderContext.antialias,
              //     stencil: true//设置可以使用模板（用于不规则遮罩）
              // };
              // let gl: any;
              // //todo 是否使用chrome源码names
              // //let contextNames = ["moz-webgl", "webkit-3d", "experimental-webgl", "webgl", "3d"];
              // let names = ["webgl", "experimental-webgl"];
              // for (let i = 0; i < names.length; i++) {
              //     try {
              //         gl = this.surface.getContext(names[i], options);
              //     } catch (e) {
              //     }
              //     if (gl) {
              //         break;
              //     }
              // }
              // if (!gl) {
              //     $error(1021);
              // }
              // this.setContext(gl);
              this.setContext(window['canvas'].getContext('webgl'));
          };
          WebGLRenderContext.prototype.setContext = function (gl) {
              this.context = gl;
              gl.id = WebGLRenderContext.glContextId++;
              this.glID = gl.id;
              gl.disable(gl.DEPTH_TEST);
              gl.disable(gl.CULL_FACE);
              gl.enable(gl.BLEND);
              gl.colorMask(true, true, true, true);
              // 目前只使用0号材质单元，默认开启
              gl.activeTexture(gl.TEXTURE0);
          };
          /**
           * 开启模版检测
           */
          WebGLRenderContext.prototype.enableStencilTest = function () {
              var gl = this.context;
              gl.enable(gl.STENCIL_TEST);
          };
          /**
           * 关闭模版检测
           */
          WebGLRenderContext.prototype.disableStencilTest = function () {
              var gl = this.context;
              gl.disable(gl.STENCIL_TEST);
          };
          /**
           * 开启scissor检测
           */
          WebGLRenderContext.prototype.enableScissorTest = function (rect) {
              var gl = this.context;
              gl.enable(gl.SCISSOR_TEST);
              gl.scissor(rect.x, rect.y, rect.width, rect.height);
          };
          /**
           * 关闭scissor检测
           */
          WebGLRenderContext.prototype.disableScissorTest = function () {
              var gl = this.context;
              gl.disable(gl.SCISSOR_TEST);
          };
          /**
           * 获取像素信息
           */
          WebGLRenderContext.prototype.getPixels = function (x, y, width, height, pixels) {
              var gl = this.context;
              gl.readPixels(x, y, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
          };
          /**
           * 创建一个WebGLTexture
           */
          WebGLRenderContext.prototype.createTexture = function (bitmapData) {
              var gl = this.context;
              if (bitmapData == window["sharedCanvas"] && gl.wxBindCanvasTexture != null) {
                  return bitmapData;
              }
              var texture = gl.createTexture();
              if (!texture) {
                  //先创建texture失败,然后lost事件才发出来..
                  this.contextLost = true;
                  return;
              }
              texture.glContext = gl;
              gl.bindTexture(gl.TEXTURE_2D, texture);
              gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
              gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmapData);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
              gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
              return texture;
          };
          WebGLRenderContext.prototype.createTextureFromCompressedData = function (data, width, height, levels, internalFormat) {
              return null;
          };
          /**
           * 更新材质的bitmapData
           */
          WebGLRenderContext.prototype.updateTexture = function (texture, bitmapData) {
              var gl = this.context;
              gl.bindTexture(gl.TEXTURE_2D, texture);
              gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmapData);
          };
          /**
           * 获取一个WebGLTexture
           * 如果有缓存的texture返回缓存的texture，如果没有则创建并缓存texture
           */
          WebGLRenderContext.prototype.getWebGLTexture = function (bitmapData) {
              if (!bitmapData.webGLTexture) {
                  if (bitmapData.format == "image") {
                      bitmapData.webGLTexture = this.createTexture(bitmapData.source);
                  }
                  else if (bitmapData.format == "pvr") {
                      bitmapData.webGLTexture = this.createTextureFromCompressedData(bitmapData.source.pvrtcData, bitmapData.width, bitmapData.height, bitmapData.source.mipmapsCount, bitmapData.source.format);
                  }
                  if (bitmapData.$deleteSource && bitmapData.webGLTexture) {
                      bitmapData.source = null;
                  }
                  //todo 默认值
                  bitmapData.webGLTexture["smoothing"] = true;
              }
              return bitmapData.webGLTexture;
          };
          /**
           * 清除矩形区域
           */
          //目前没有引用
          WebGLRenderContext.prototype.clearRect = function (x, y, width, height) {
              if (x != 0 || y != 0 || width != this.surface.width || height != this.surface.height) {
                  var buffer = this.currentBuffer;
                  if (buffer.$hasScissor) {
                      this.setGlobalCompositeOperation("destination-out");
                      this.setGlobalCompositeOperation("source-over");
                  }
                  else {
                      var m = buffer.globalMatrix;
                      if (m.b == 0 && m.c == 0) {
                          x = x * m.a + m.tx;
                          y = y * m.d + m.ty;
                          width = width * m.a;
                          height = height * m.d;
                          this.enableScissor(x, -y - height + buffer.height, width, height);
                          this.clear();
                          this.disableScissor();
                      }
                      else {
                          this.setGlobalCompositeOperation("destination-out");
                          // this.drawRect(x, y, width, height);
                          this.setGlobalCompositeOperation("source-over");
                      }
                  }
              }
              else {
                  this.clear();
              }
          };
          /**
           * 设置混色
           */
          WebGLRenderContext.prototype.setGlobalCompositeOperation = function (value) {
              this.drawCmdManager.pushSetBlend(value);
          };
          /**
           * 绘制图片，image参数可以是BitmapData或者renderTarget
           */
          WebGLRenderContext.prototype.drawImage = function (image, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, imageSourceWidth, imageSourceHeight, rotated, smoothing) {
              var buffer = this.currentBuffer;
              if (this.contextLost || !image || !buffer) {
                  return;
              }
              var texture;
              var offsetX;
              var offsetY;
              if (image["texture"] || (image.source && image.source["texture"])) {
                  // 如果是render target
                  texture = image["texture"] || image.source["texture"];
                  buffer.saveTransform();
                  offsetX = buffer.$offsetX;
                  offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(1, 0, 0, -1, 0, destHeight + destY * 2); // 翻转
              }
              else if (!image.source && !image.webGLTexture) {
                  return;
              }
              else {
                  texture = this.getWebGLTexture(image);
              }
              if (!texture) {
                  return;
              }
              this.drawTexture(texture, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, imageSourceWidth, imageSourceHeight, undefined, undefined, undefined, undefined, rotated, smoothing);
              if (image.source && image.source["texture"]) {
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  buffer.restoreTransform();
              }
          };
          /**
           * 绘制图片，image参数可以是BitmapData或者renderTarget
           * 同样的功能，单参数，整合drawTexture部分
           */
          WebGLRenderContext.prototype.drawImageByRenderNode = function (node) {
              var buffer = this.currentBuffer;
              var image = node.image;
              var destHeight = node.drawH;
              var destWidth = node.drawW;
              var destX = node.drawX;
              var destY = node.drawY;
              if (this.contextLost || !image || !buffer) {
                  return;
              }
              var texture;
              var buffer_offsetX;
              var buffer_offsetY;
              if (image["texture"] || (image.source && image.source["texture"])) {
                  // 如果是render target
                  texture = image["texture"] || image.source["texture"];
                  buffer.saveTransform();
                  buffer_offsetX = buffer.$offsetX;
                  buffer_offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(1, 0, 0, -1, 0, destHeight + destY * 2); // 翻转
              }
              else if (!image.source && !image.webGLTexture) {
                  return;
              }
              else {
                  texture = this.getWebGLTexture(image);
              }
              if (!texture) {
                  return;
              }
              //drawTexture
              if (this.vao.reachVertexMaxSize()) {
                  this.$drawWebGL();
              }
              var smoothing = node.smoothing;
              if (smoothing != undefined && texture["smoothing"] != smoothing) {
                  this.drawCmdManager.pushChangeSmoothing(texture, smoothing);
              }
              var count = 2;
              var width = node.imageWidth;
              var height = node.imageHeight;
              // 应用$filter，因为只可能是colorMatrixFilter，最后两个参数可不传
              this.drawCmdManager.pushDrawTexture(texture, count, this.$filter, width, height);
              //cacheArray
              var locWorldTransform = buffer.globalMatrix;
              var a = locWorldTransform.a;
              var b = locWorldTransform.b;
              var c = locWorldTransform.c;
              var d = locWorldTransform.d;
              var tx = locWorldTransform.tx;
              var ty = locWorldTransform.ty;
              var offsetX = buffer.$offsetX;
              var offsetY = buffer.$offsetY;
              if (offsetX != 0 || offsetY != 0) {
                  tx = offsetX * a + offsetY * c + tx;
                  ty = offsetX * b + offsetY * d + ty;
              }
              if (destX != 0 || destY != 0) {
                  tx = destX * a + destY * c + tx;
                  ty = destX * b + destY * d + ty;
              }
              var sourceWidth = node.sourceW;
              var sourceHeight = node.sourceH;
              var rotated = node.rotated;
              var a1 = destWidth / sourceWidth;
              if (a1 != 1) {
                  a = a1 * a;
                  b = a1 * b;
              }
              var d1 = destHeight / sourceHeight;
              if (d1 != 1) {
                  c = d1 * c;
                  d = d1 * d;
              }
              var float32Array = this.vao.float32Array;
              var uint32Array = this.vao.uint32Array;
              var index = this.vao.vertexIndex * this.vao.vertSize;
              var alpha = buffer.globalAlpha;
              var a_w = a * sourceWidth;
              var b_w = b * sourceWidth;
              var c_h = c * sourceHeight;
              var d_h = d * sourceHeight;
              // xy
              float32Array[index++] = tx;
              float32Array[index++] = ty;
              // uv
              uint32Array[index++] = node.uvs[0];
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = a_w + tx;
              float32Array[index++] = b_w + ty;
              // uv
              uint32Array[index++] = node.uvs[1];
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = a_w + c_h + tx;
              float32Array[index++] = d_h + b_w + ty;
              // uv
              uint32Array[index++] = node.uvs[2];
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = c_h + tx;
              float32Array[index++] = d_h + ty;
              // uv
              uint32Array[index++] = node.uvs[3];
              // alpha
              float32Array[index++] = alpha;
              this.vao.vertexIndex += 4;
              this.vao.indexIndex += 6;
              if (image.source && image.source["texture"]) {
                  buffer.$offsetX = buffer_offsetX;
                  buffer.$offsetY = buffer_offsetY;
                  buffer.restoreTransform();
              }
          };
          /**
           * 绘制Mesh
           */
          WebGLRenderContext.prototype.drawMesh = function (image, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, imageSourceWidth, imageSourceHeight, meshUVs, meshVertices, meshIndices, bounds, rotated, smoothing) {
              var buffer = this.currentBuffer;
              if (this.contextLost || !image || !buffer) {
                  return;
              }
              var texture;
              var offsetX;
              var offsetY;
              if (image["texture"] || (image.source && image.source["texture"])) {
                  // 如果是render target
                  texture = image["texture"] || image.source["texture"];
                  buffer.saveTransform();
                  offsetX = buffer.$offsetX;
                  offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(1, 0, 0, -1, 0, destHeight + destY * 2); // 翻转
              }
              else if (!image.source && !image.webGLTexture) {
                  return;
              }
              else {
                  texture = this.getWebGLTexture(image);
              }
              if (!texture) {
                  return;
              }
              this.drawTexture(texture, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, imageSourceWidth, imageSourceHeight, meshUVs, meshVertices, meshIndices, bounds, rotated, smoothing);
              if (image["texture"] || (image.source && image.source["texture"])) {
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  buffer.restoreTransform();
              }
          };
          /**
           * 绘制材质
           */
          WebGLRenderContext.prototype.drawTexture = function (texture, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, textureWidth, textureHeight, meshUVs, meshVertices, meshIndices, bounds, rotated, smoothing) {
              var buffer = this.currentBuffer;
              if (this.contextLost || !texture || !buffer) {
                  return;
              }
              if (meshVertices && meshIndices) {
                  if (this.vao.reachMaxSize(meshVertices.length / 2, meshIndices.length)) {
                      this.$drawWebGL();
                  }
              }
              else {
                  if (this.vao.reachMaxSize()) {
                      this.$drawWebGL();
                  }
              }
              if (smoothing != undefined && texture["smoothing"] != smoothing) {
                  this.drawCmdManager.pushChangeSmoothing(texture, smoothing);
              }
              if (meshUVs) {
                  this.vao.changeToMeshIndices();
              }
              var count = meshIndices ? meshIndices.length / 3 : 2;
              // 应用$filter，因为只可能是colorMatrixFilter，最后两个参数可不传
              this.drawCmdManager.pushDrawTexture(texture, count, this.$filter, textureWidth, textureHeight);
              this.vao.cacheArrays(buffer, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, textureWidth, textureHeight, meshUVs, meshVertices, meshIndices, rotated);
          };
          WebGLRenderContext.prototype.drawTextureByRenderNode = function (node) {
              var texture = node.$texture;
              var sourceWidth = node.$textureWidth;
              var sourceHeight = node.$textureHeight;
              var canvasScaleX = egret.sys.DisplayList.$canvasScaleX;
              var canvasScaleY = egret.sys.DisplayList.$canvasScaleY;
              var destWidth = node.$textureWidth / canvasScaleX;
              var destHeight = node.$textureHeight / canvasScaleY;
              var buffer = this.currentBuffer;
              if (this.contextLost || !texture || !buffer) {
                  return;
              }
              if (this.vao.reachMaxSize()) {
                  this.$drawWebGL();
              }
              var count = 2;
              // 应用$filter，因为只可能是colorMatrixFilter，最后两个参数可不传
              this.drawCmdManager.pushDrawTexture(texture, count, this.$filter, sourceWidth, sourceHeight);
              //cacheArray
              var locWorldTransform = buffer.globalMatrix;
              var a = locWorldTransform.a;
              var b = locWorldTransform.b;
              var c = locWorldTransform.c;
              var d = locWorldTransform.d;
              var tx = locWorldTransform.tx;
              var ty = locWorldTransform.ty;
              var offsetX = buffer.$offsetX;
              var offsetY = buffer.$offsetY;
              if (offsetX != 0 || offsetY != 0) {
                  tx = offsetX * a + offsetY * c + tx;
                  ty = offsetX * b + offsetY * d + ty;
              }
              var a1 = destWidth / sourceWidth;
              if (a1 != 1) {
                  a = a1 * a;
                  b = a1 * b;
              }
              var d1 = destHeight / sourceHeight;
              if (d1 != 1) {
                  c = d1 * c;
                  d = d1 * d;
              }
              var float32Array = this.vao.float32Array;
              var uint32Array = this.vao.uint32Array;
              var index = this.vao.vertexIndex * this.vao.vertSize;
              var alpha = buffer.globalAlpha;
              var a_w = a * sourceWidth;
              var b_w = b * sourceWidth;
              var c_h = c * sourceHeight;
              var d_h = d * sourceHeight;
              // xy
              float32Array[index++] = tx;
              float32Array[index++] = ty;
              // uv
              uint32Array[index++] = 0;
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = a_w + tx;
              float32Array[index++] = b_w + ty;
              // uv
              uint32Array[index++] = 65535;
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = a_w + c_h + tx;
              float32Array[index++] = d_h + b_w + ty;
              // uv
              uint32Array[index++] = 65535 << 16 | 65535;
              // alpha
              float32Array[index++] = alpha;
              // xy
              float32Array[index++] = c_h + tx;
              float32Array[index++] = d_h + ty;
              // uv
              uint32Array[index++] = 65535 << 16;
              // alpha
              float32Array[index++] = alpha;
              this.vao.vertexIndex += 4;
              this.vao.indexIndex += 6;
          };
          /**
           * 绘制遮罩
           */
          WebGLRenderContext.prototype.pushMask = function (x, y, width, height) {
              var buffer = this.currentBuffer;
              if (this.contextLost || !buffer) {
                  return;
              }
              buffer.$stencilList.push({ x: x, y: y, width: width, height: height });
              if (this.vao.reachMaxSize()) {
                  this.$drawWebGL();
              }
              this.drawCmdManager.pushPushMask();
              this.vao.cacheArrays(buffer, 0, 0, width, height, x, y, width, height, width, height);
          };
          /**
           * 恢复遮罩
           */
          WebGLRenderContext.prototype.popMask = function () {
              var buffer = this.currentBuffer;
              if (this.contextLost || !buffer) {
                  return;
              }
              var mask = buffer.$stencilList.pop();
              if (this.vao.reachMaxSize()) {
                  this.$drawWebGL();
              }
              this.drawCmdManager.pushPopMask();
              this.vao.cacheArrays(buffer, 0, 0, mask.width, mask.height, mask.x, mask.y, mask.width, mask.height, mask.width, mask.height);
          };
          /**
           * 清除颜色缓存
           */
          WebGLRenderContext.prototype.clear = function () {
              this.drawCmdManager.pushClearColor();
          };
          /**
           * 开启scissor test
           */
          WebGLRenderContext.prototype.enableScissor = function (x, y, width, height) {
              var buffer = this.currentBuffer;
              this.drawCmdManager.pushEnableScissor(x, y, width, height);
              buffer.$hasScissor = true;
          };
          /**
           * 关闭scissor test
           */
          WebGLRenderContext.prototype.disableScissor = function () {
              var buffer = this.currentBuffer;
              this.drawCmdManager.pushDisableScissor();
              buffer.$hasScissor = false;
          };
          WebGLRenderContext.prototype.$drawWebGL = function () {
              //for 3D&2D
              // (this as any).drawFunc();
              //for only2D
              if (this.drawCmdManager.drawDataLen == 0 || this.contextLost) {
                  return;
              }
              this.uploadVerticesArray(this.vao.getVertices());
              // 有mesh，则使用indicesForMesh
              if (this.vao.isMesh()) {
                  this.uploadIndicesArray(this.vao.getMeshIndices());
              }
              var length = this.drawCmdManager.drawDataLen;
              var offset = 0;
              for (var i = 0; i < length; i++) {
                  var data = this.drawCmdManager.drawData[i];
                  if (!data) {
                      continue;
                  }
                  offset = this.drawData(data, offset);
                  // 计算draw call
                  if (data.type == 6 /* ACT_BUFFER */) {
                      this.activatedBuffer = data.buffer;
                  }
                  if (data.type != 0 /* TEXTURE */ && data.type != 1 /* PUSH_MASK */ && data.type != 2 /* POP_MASK */) {
                      continue;
                  }
                  if (this.activatedBuffer && this.activatedBuffer.$computeDrawCall) {
                      this.activatedBuffer.$drawCalls++;
                  }
              }
              // 切换回默认indices
              if (this.vao.isMesh()) {
                  this.uploadIndicesArray(this.vao.getIndices());
              }
              // 清空数据
              this.drawCmdManager.clear();
              this.vao.clear();
          };
          /**
           * 执行绘制命令
           */
          WebGLRenderContext.prototype.drawData = function (data, offset) {
              if (!data) {
                  return;
              }
              var gl = this.context;
              var program;
              var filter = data.filter;
              switch (data.type) {
                  case 10 /* CHANGE_PROGRAM */:
                      program = wxgame.EgretWebGLProgram.getProgram(gl, data.vertSource, data.fragSource, data.key);
                      this.activeProgram(gl, program);
                      break;
                  case 0 /* TEXTURE */:
                      this.syncUniforms(this.currentProgram, filter, data.textureWidth, data.textureHeight);
                      offset += this.drawTextureElements(data, offset);
                      break;
                  case 1 /* PUSH_MASK */:
                      this.syncUniforms(this.currentProgram, filter, data.textureWidth, data.textureHeight);
                      offset += this.drawPushMaskElements(data, offset);
                      break;
                  case 2 /* POP_MASK */:
                      this.syncUniforms(this.currentProgram, filter, data.textureWidth, data.textureHeight);
                      offset += this.drawPopMaskElements(data, offset);
                      break;
                  case 3 /* BLEND */:
                      this.setBlendMode(data.value);
                      break;
                  case 4 /* RESIZE_TARGET */:
                      data.buffer.rootRenderTarget.resize(data.width, data.height);
                      this.onResize(data.width, data.height);
                      break;
                  case 5 /* CLEAR_COLOR */:
                      if (this.activatedBuffer) {
                          var target = this.activatedBuffer.rootRenderTarget;
                          if (target.width != 0 || target.height != 0) {
                              target.clear(true);
                          }
                      }
                      break;
                  case 6 /* ACT_BUFFER */:
                      this.activateBuffer(data.buffer);
                      break;
                  case 7 /* ENABLE_SCISSOR */:
                      var buffer = this.activatedBuffer;
                      if (buffer) {
                          if (buffer.rootRenderTarget) {
                              buffer.rootRenderTarget.enabledStencil();
                          }
                          buffer.enableScissor(data.x, data.y, data.width, data.height);
                      }
                      break;
                  case 8 /* DISABLE_SCISSOR */:
                      buffer = this.activatedBuffer;
                      if (buffer) {
                          buffer.disableScissor();
                      }
                      break;
                  case 9 /* SMOOTHING */:
                      gl.bindTexture(gl.TEXTURE_2D, data.texture);
                      if (data.smoothing) {
                          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
                          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
                      }
                      else {
                          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
                          gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
                      }
                      break;
                  default:
                      break;
              }
              return offset;
          };
          WebGLRenderContext.prototype.activeProgram = function (gl, program) {
              if (program != this.currentProgram) {
                  gl.useProgram(program.id);
                  // 目前所有attribute buffer的绑定方法都是一致的
                  var attribute = program.attributes;
                  for (var key in attribute) {
                      if (key === "aVertexPosition") {
                          gl.vertexAttribPointer(attribute["aVertexPosition"].location, 2, gl.FLOAT, false, 4 * 4, 0);
                          gl.enableVertexAttribArray(attribute["aVertexPosition"].location);
                      }
                      else if (key === "aTextureCoord") {
                          gl.vertexAttribPointer(attribute["aTextureCoord"].location, 2, gl.UNSIGNED_SHORT, true, 4 * 4, 2 * 4);
                          gl.enableVertexAttribArray(attribute["aTextureCoord"].location);
                      }
                      else if (key === "aColor") {
                          gl.vertexAttribPointer(attribute["aColor"].location, 1, gl.FLOAT, false, 4 * 4, 3 * 4);
                          gl.enableVertexAttribArray(attribute["aColor"].location);
                      }
                  }
                  this.currentProgram = program;
              }
          };
          WebGLRenderContext.prototype.syncUniforms = function (program, filter, textureWidth, textureHeight) {
              var uniforms = program.uniforms;
              var isCustomFilter = filter && filter.type === "custom";
              for (var key in uniforms) {
                  if (key === "projectionVector") {
                      uniforms[key].setValue({ x: this.projectionX, y: this.projectionY });
                  }
                  else if (key === "uTextureSize") {
                      uniforms[key].setValue({ x: textureWidth, y: textureHeight });
                  }
                  else if (key === "uSampler") {
                  }
                  else {
                      var value = filter.$uniforms[key];
                      if (value !== undefined) {
                          uniforms[key].setValue(value);
                      }
                      else {
                          // egret.warn("filter custom: uniform " + key + " not defined!");
                      }
                  }
              }
          };
          /**
           * 画texture
           **/
          WebGLRenderContext.prototype.drawTextureElements = function (data, offset) {
              var gl = this.context;
              if (data.texture == window["sharedCanvas"]) {
                  gl.wxBindCanvasTexture(gl.TEXTURE_2D, window["sharedCanvas"]);
              }
              else {
                  gl.bindTexture(gl.TEXTURE_2D, data.texture);
              }
              var size = data.count * 3;
              gl.drawElements(gl.TRIANGLES, size, gl.UNSIGNED_SHORT, offset * 2);
              return size;
          };
          /**
           * 画push mask
           **/
          WebGLRenderContext.prototype.drawPushMaskElements = function (data, offset) {
              var gl = this.context;
              var size = data.count * 3;
              var buffer = this.activatedBuffer;
              if (buffer) {
                  if (buffer.rootRenderTarget) {
                      buffer.rootRenderTarget.enabledStencil();
                  }
                  if (buffer.stencilHandleCount == 0) {
                      buffer.enableStencil();
                      gl.clear(gl.STENCIL_BUFFER_BIT); // clear
                  }
                  var level = buffer.stencilHandleCount;
                  buffer.stencilHandleCount++;
                  gl.colorMask(false, false, false, false);
                  gl.stencilFunc(gl.EQUAL, level, 0xFF);
                  gl.stencilOp(gl.KEEP, gl.KEEP, gl.INCR);
                  // gl.bindTexture(gl.TEXTURE_2D, null);
                  gl.drawElements(gl.TRIANGLES, size, gl.UNSIGNED_SHORT, offset * 2);
                  gl.stencilFunc(gl.EQUAL, level + 1, 0xFF);
                  gl.colorMask(true, true, true, true);
                  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
              }
              return size;
          };
          /**
           * 画pop mask
           **/
          WebGLRenderContext.prototype.drawPopMaskElements = function (data, offset) {
              var gl = this.context;
              var size = data.count * 3;
              var buffer = this.activatedBuffer;
              if (buffer) {
                  buffer.stencilHandleCount--;
                  if (buffer.stencilHandleCount == 0) {
                      buffer.disableStencil(); // skip this draw
                  }
                  else {
                      var level = buffer.stencilHandleCount;
                      gl.colorMask(false, false, false, false);
                      gl.stencilFunc(gl.EQUAL, level + 1, 0xFF);
                      gl.stencilOp(gl.KEEP, gl.KEEP, gl.DECR);
                      // gl.bindTexture(gl.TEXTURE_2D, null);
                      gl.drawElements(gl.TRIANGLES, size, gl.UNSIGNED_SHORT, offset * 2);
                      gl.stencilFunc(gl.EQUAL, level, 0xFF);
                      gl.colorMask(true, true, true, true);
                      gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
                  }
              }
              return size;
          };
          /**
           * 设置混色
           */
          WebGLRenderContext.prototype.setBlendMode = function (value) {
              var gl = this.context;
              var blendModeWebGL = WebGLRenderContext.blendModesForGL[value];
              if (blendModeWebGL) {
                  gl.blendFunc(blendModeWebGL[0], blendModeWebGL[1]);
              }
          };
          /**
           * 应用滤镜绘制给定的render target
           * 此方法不会导致input被释放，所以如果需要释放input，需要调用此方法后手动调用release
           */
          WebGLRenderContext.prototype.drawTargetWidthFilters = function (filters, input) {
              var originInput = input, filtersLen = filters.length, output;
              // 应用前面的滤镜
              if (filtersLen > 1) {
                  for (var i = 0; i < filtersLen - 1; i++) {
                      var filter_1 = filters[i];
                      var width = input.rootRenderTarget.width;
                      var height = input.rootRenderTarget.height;
                      output = wxgame.WebGLRenderBuffer.create(width, height);
                      output.setTransform(1, 0, 0, 1, 0, 0);
                      output.globalAlpha = 1;
                      this.drawToRenderTarget(filter_1, input, output);
                      if (input != originInput) {
                          wxgame.WebGLRenderBuffer.release(input);
                      }
                      input = output;
                  }
              }
              // 应用最后一个滤镜并绘制到当前场景中
              var filter = filters[filtersLen - 1];
              this.drawToRenderTarget(filter, input, this.currentBuffer);
              // 释放掉用于交换的buffer
              if (input != originInput) {
                  wxgame.WebGLRenderBuffer.release(input);
              }
          };
          /**
           * 向一个renderTarget中绘制
           * */
          WebGLRenderContext.prototype.drawToRenderTarget = function (filter, input, output) {
              if (this.contextLost) {
                  return;
              }
              if (this.vao.reachMaxSize()) {
                  this.$drawWebGL();
              }
              this.pushBuffer(output);
              var originInput = input, temp, width = input.rootRenderTarget.width, height = input.rootRenderTarget.height;
              // 模糊滤镜分别处理blurX与blurY
              if (filter.type == "blur") {
                  var blurXFilter = filter.blurXFilter;
                  var blurYFilter = filter.blurYFilter;
                  if (blurXFilter.blurX != 0 && blurYFilter.blurY != 0) {
                      temp = wxgame.WebGLRenderBuffer.create(width, height);
                      temp.setTransform(1, 0, 0, 1, 0, 0);
                      temp.globalAlpha = 1;
                      this.drawToRenderTarget(filter.blurXFilter, input, temp);
                      if (input != originInput) {
                          wxgame.WebGLRenderBuffer.release(input);
                      }
                      input = temp;
                      filter = blurYFilter;
                  }
                  else {
                      filter = blurXFilter.blurX === 0 ? blurYFilter : blurXFilter;
                  }
              }
              // 绘制input结果到舞台
              output.saveTransform();
              output.transform(1, 0, 0, -1, 0, height);
              this.vao.cacheArrays(output, 0, 0, width, height, 0, 0, width, height, width, height);
              output.restoreTransform();
              this.drawCmdManager.pushDrawTexture(input.rootRenderTarget.texture, 2, filter, width, height);
              // 释放掉input
              if (input != originInput) {
                  wxgame.WebGLRenderBuffer.release(input);
              }
              this.popBuffer();
          };
          WebGLRenderContext.initBlendMode = function () {
              WebGLRenderContext.blendModesForGL = {};
              WebGLRenderContext.blendModesForGL["source-over"] = [1, 771];
              WebGLRenderContext.blendModesForGL["lighter"] = [1, 1];
              WebGLRenderContext.blendModesForGL["lighter-in"] = [770, 771];
              WebGLRenderContext.blendModesForGL["destination-out"] = [0, 771];
              WebGLRenderContext.blendModesForGL["destination-in"] = [0, 770];
          };
          WebGLRenderContext.glContextId = 0;
          WebGLRenderContext.blendModesForGL = null;
          return WebGLRenderContext;
      }());
      wxgame.WebGLRenderContext = WebGLRenderContext;
      __reflect(WebGLRenderContext.prototype, "egret.wxgame.WebGLRenderContext");
      WebGLRenderContext.initBlendMode();
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       * WebGL渲染缓存
       */
      var WebGLRenderBuffer = (function (_super) {
          __extends(WebGLRenderBuffer, _super);
          function WebGLRenderBuffer(width, height, root) {
              var _this = _super.call(this) || this;
              _this.globalAlpha = 1;
              /**
               * stencil state
               * 模版开关状态
               */
              _this.stencilState = false;
              _this.$stencilList = [];
              _this.stencilHandleCount = 0;
              /**
               * scissor state
               * scissor 开关状态
               */
              _this.$scissorState = false;
              _this.scissorRect = new egret.Rectangle();
              _this.$hasScissor = false;
              _this.$drawCalls = 0;
              _this.$computeDrawCall = false;
              _this.globalMatrix = new egret.Matrix();
              _this.savedGlobalMatrix = new egret.Matrix();
              _this.$offsetX = 0;
              _this.$offsetY = 0;
              // 获取webglRenderContext
              _this.context = wxgame.WebGLRenderContext.getInstance(width, height);
              // buffer 对应的 render target
              _this.rootRenderTarget = new wxgame.WebGLRenderTarget(_this.context.context, 3, 3);
              if (width && height) {
                  _this.resize(width, height);
              }
              // 如果是第一个加入的buffer，说明是舞台buffer
              _this.root = root;
              // 如果是用于舞台渲染的renderBuffer，则默认添加renderTarget到renderContext中，而且是第一个
              if (_this.root) {
                  _this.context.pushBuffer(_this);
                  // 画布
                  _this.surface = _this.context.surface;
                  _this.$computeDrawCall = true;
              }
              else {
                  // 由于创建renderTarget造成的frameBuffer绑定，这里重置绑定
                  var lastBuffer = _this.context.activatedBuffer;
                  if (lastBuffer) {
                      lastBuffer.rootRenderTarget.activate();
                  }
                  _this.rootRenderTarget.initFrameBuffer();
                  _this.surface = _this.rootRenderTarget;
              }
              return _this;
          }
          WebGLRenderBuffer.prototype.enableStencil = function () {
              if (!this.stencilState) {
                  this.context.enableStencilTest();
                  this.stencilState = true;
              }
          };
          WebGLRenderBuffer.prototype.disableStencil = function () {
              if (this.stencilState) {
                  this.context.disableStencilTest();
                  this.stencilState = false;
              }
          };
          WebGLRenderBuffer.prototype.restoreStencil = function () {
              if (this.stencilState) {
                  this.context.enableStencilTest();
              }
              else {
                  this.context.disableStencilTest();
              }
          };
          WebGLRenderBuffer.prototype.enableScissor = function (x, y, width, height) {
              if (!this.$scissorState) {
                  this.$scissorState = true;
                  this.scissorRect.setTo(x, y, width, height);
                  this.context.enableScissorTest(this.scissorRect);
              }
          };
          WebGLRenderBuffer.prototype.disableScissor = function () {
              if (this.$scissorState) {
                  this.$scissorState = false;
                  this.scissorRect.setEmpty();
                  this.context.disableScissorTest();
              }
          };
          WebGLRenderBuffer.prototype.restoreScissor = function () {
              if (this.$scissorState) {
                  this.context.enableScissorTest(this.scissorRect);
              }
              else {
                  this.context.disableScissorTest();
              }
          };
          Object.defineProperty(WebGLRenderBuffer.prototype, "width", {
              /**
               * 渲染缓冲的宽度，以像素为单位。
               * @readOnly
               */
              get: function () {
                  return this.rootRenderTarget.width;
              },
              enumerable: true,
              configurable: true
          });
          Object.defineProperty(WebGLRenderBuffer.prototype, "height", {
              /**
               * 渲染缓冲的高度，以像素为单位。
               * @readOnly
               */
              get: function () {
                  return this.rootRenderTarget.height;
              },
              enumerable: true,
              configurable: true
          });
          /**
           * 改变渲染缓冲的大小并清空缓冲区
           * @param width 改变后的宽
           * @param height 改变后的高
           * @param useMaxSize 若传入true，则将改变后的尺寸与已有尺寸对比，保留较大的尺寸。
           */
          WebGLRenderBuffer.prototype.resize = function (width, height, useMaxSize) {
              width = width || 1;
              height = height || 1;
              if (egret.nativeRender) {
                  this.surface.resize(width, height);
                  return;
              }
              this.context.pushBuffer(this);
              // render target 尺寸重置
              if (width != this.rootRenderTarget.width || height != this.rootRenderTarget.height) {
                  this.context.drawCmdManager.pushResize(this, width, height);
                  // 同步更改宽高
                  this.rootRenderTarget.width = width;
                  this.rootRenderTarget.height = height;
              }
              //for 3D&2D
              //3D不需要主动resize,而是由3D部分进行修改
              // 如果是舞台的渲染缓冲，执行resize，否则surface大小不随之改变
              if (this.root) {
                  this.context.resize(width, height, useMaxSize);
              }
              this.context.clear();
              this.context.popBuffer();
          };
          WebGLRenderBuffer.prototype.$pushResize = function (width, height) {
              this.context.drawCmdManager.pushResize(this, width, height);
          };
          /**
           * 获取指定区域的像素
           */
          WebGLRenderBuffer.prototype.getPixels = function (x, y, width, height) {
              if (width === void 0) { width = 1; }
              if (height === void 0) { height = 1; }
              var pixels = new Uint8Array(4 * width * height);
              if (egret.nativeRender) {
                  egret_native.activateBuffer(this);
                  egret_native.nrGetPixels(x, y, width, height, pixels);
                  egret_native.activateBuffer(null);
              }
              else {
                  var useFrameBuffer = this.rootRenderTarget.useFrameBuffer;
                  this.rootRenderTarget.useFrameBuffer = true;
                  this.rootRenderTarget.activate();
                  this.context.getPixels(x, y, width, height, pixels);
                  this.rootRenderTarget.useFrameBuffer = useFrameBuffer;
                  this.rootRenderTarget.activate();
              }
              //图像反转
              var result = new Uint8Array(4 * width * height);
              for (var i = 0; i < height; i++) {
                  for (var j = 0; j < width; j++) {
                      var index1 = (width * (height - i - 1) + j) * 4;
                      var index2 = (width * i + j) * 4;
                      var a = pixels[index2 + 3];
                      result[index1] = Math.round(pixels[index2] / a * 255);
                      result[index1 + 1] = Math.round(pixels[index2 + 1] / a * 255);
                      result[index1 + 2] = Math.round(pixels[index2 + 2] / a * 255);
                      result[index1 + 3] = pixels[index2 + 3];
                  }
              }
              return result;
          };
          /**
           * 转换成base64字符串，如果图片（或者包含的图片）跨域，则返回null
           * @param type 转换的类型，如: "image/png","image/jpeg"
           */
          WebGLRenderBuffer.prototype.toDataURL = function (type, encoderOptions) {
              return this.context.surface.toDataURL(type, encoderOptions);
          };
          /**
           * 销毁绘制对象
           */
          WebGLRenderBuffer.prototype.destroy = function () {
              this.context.destroy();
          };
          WebGLRenderBuffer.prototype.onRenderFinish = function () {
              this.$drawCalls = 0;
          };
          /**
           * 交换frameBuffer中的图像到surface中
           * @param width 宽度
           * @param height 高度
           */
          WebGLRenderBuffer.prototype.drawFrameBufferToSurface = function (sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, clear) {
              if (clear === void 0) { clear = false; }
              this.rootRenderTarget.useFrameBuffer = false;
              this.rootRenderTarget.activate();
              this.context.disableStencilTest(); // 切换frameBuffer注意要禁用STENCIL_TEST
              this.context.disableScissorTest();
              this.setTransform(1, 0, 0, 1, 0, 0);
              this.globalAlpha = 1;
              this.context.setGlobalCompositeOperation("source-over");
              clear && this.context.clear();
              this.context.drawImage(this.rootRenderTarget, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, sourceWidth, sourceHeight, false);
              this.context.$drawWebGL();
              this.rootRenderTarget.useFrameBuffer = true;
              this.rootRenderTarget.activate();
              this.restoreStencil();
              this.restoreScissor();
          };
          /**
           * 交换surface的图像到frameBuffer中
           * @param width 宽度
           * @param height 高度
           */
          WebGLRenderBuffer.prototype.drawSurfaceToFrameBuffer = function (sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, clear) {
              if (clear === void 0) { clear = false; }
              this.rootRenderTarget.useFrameBuffer = true;
              this.rootRenderTarget.activate();
              this.context.disableStencilTest(); // 切换frameBuffer注意要禁用STENCIL_TEST
              this.context.disableScissorTest();
              this.setTransform(1, 0, 0, 1, 0, 0);
              this.globalAlpha = 1;
              this.context.setGlobalCompositeOperation("source-over");
              clear && this.context.clear();
              this.context.drawImage(this.context.surface, sourceX, sourceY, sourceWidth, sourceHeight, destX, destY, destWidth, destHeight, sourceWidth, sourceHeight, false);
              this.context.$drawWebGL();
              this.rootRenderTarget.useFrameBuffer = false;
              this.rootRenderTarget.activate();
              this.restoreStencil();
              this.restoreScissor();
          };
          /**
           * 清空缓冲区数据
           */
          WebGLRenderBuffer.prototype.clear = function () {
              this.context.pushBuffer(this);
              this.context.clear();
              this.context.popBuffer();
          };
          WebGLRenderBuffer.prototype.setTransform = function (a, b, c, d, tx, ty) {
              // this.globalMatrix.setTo(a, b, c, d, tx, ty);
              var matrix = this.globalMatrix;
              matrix.a = a;
              matrix.b = b;
              matrix.c = c;
              matrix.d = d;
              matrix.tx = tx;
              matrix.ty = ty;
          };
          WebGLRenderBuffer.prototype.transform = function (a, b, c, d, tx, ty) {
              var matrix = this.globalMatrix;
              var a1 = matrix.a;
              var b1 = matrix.b;
              var c1 = matrix.c;
              var d1 = matrix.d;
              if (a != 1 || b != 0 || c != 0 || d != 1) {
                  matrix.a = a * a1 + b * c1;
                  matrix.b = a * b1 + b * d1;
                  matrix.c = c * a1 + d * c1;
                  matrix.d = c * b1 + d * d1;
              }
              matrix.tx = tx * a1 + ty * c1 + matrix.tx;
              matrix.ty = tx * b1 + ty * d1 + matrix.ty;
          };
          WebGLRenderBuffer.prototype.useOffset = function () {
              var self = this;
              if (self.$offsetX != 0 || self.$offsetY != 0) {
                  self.globalMatrix.append(1, 0, 0, 1, self.$offsetX, self.$offsetY);
                  self.$offsetX = self.$offsetY = 0;
              }
          };
          WebGLRenderBuffer.prototype.saveTransform = function () {
              var matrix = this.globalMatrix;
              var sMatrix = this.savedGlobalMatrix;
              sMatrix.a = matrix.a;
              sMatrix.b = matrix.b;
              sMatrix.c = matrix.c;
              sMatrix.d = matrix.d;
              sMatrix.tx = matrix.tx;
              sMatrix.ty = matrix.ty;
          };
          WebGLRenderBuffer.prototype.restoreTransform = function () {
              var matrix = this.globalMatrix;
              var sMatrix = this.savedGlobalMatrix;
              matrix.a = sMatrix.a;
              matrix.b = sMatrix.b;
              matrix.c = sMatrix.c;
              matrix.d = sMatrix.d;
              matrix.tx = sMatrix.tx;
              matrix.ty = sMatrix.ty;
          };
          /**
           * 创建一个buffer实例
           */
          WebGLRenderBuffer.create = function (width, height) {
              var buffer = renderBufferPool.pop();
              // width = Math.min(width, 1024);
              // height = Math.min(height, 1024);
              if (buffer) {
                  buffer.resize(width, height);
                  var matrix = buffer.globalMatrix;
                  matrix.a = 1;
                  matrix.b = 0;
                  matrix.c = 0;
                  matrix.d = 1;
                  matrix.tx = 0;
                  matrix.ty = 0;
                  buffer.globalAlpha = 1;
                  buffer.$offsetX = 0;
                  buffer.$offsetY = 0;
              }
              else {
                  buffer = new WebGLRenderBuffer(width, height);
                  buffer.$computeDrawCall = false;
              }
              return buffer;
          };
          /**
           * 回收一个buffer实例
           */
          WebGLRenderBuffer.release = function (buffer) {
              renderBufferPool.push(buffer);
          };
          WebGLRenderBuffer.autoClear = true;
          return WebGLRenderBuffer;
      }(egret.HashObject));
      wxgame.WebGLRenderBuffer = WebGLRenderBuffer;
      __reflect(WebGLRenderBuffer.prototype, "egret.wxgame.WebGLRenderBuffer", ["egret.sys.RenderBuffer"]);
      var renderBufferPool = []; //渲染缓冲区对象池
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      var blendModes = ["source-over", "lighter", "destination-out"];
      var defaultCompositeOp = "source-over";
      var BLACK_COLOR = "#000000";
      var CAPS_STYLES = { none: 'butt', square: 'square', round: 'round' };
      var renderBufferPool = []; //渲染缓冲区对象池
      /**
       * @private
       * WebGL渲染器
       */
      var WebGLRenderer = (function () {
          function WebGLRenderer() {
              this.nestLevel = 0; //渲染的嵌套层次，0表示在调用堆栈的最外层。
          }
          /**
           * 渲染一个显示对象
           * @param displayObject 要渲染的显示对象
           * @param buffer 渲染缓冲
           * @param matrix 要对显示对象整体叠加的变换矩阵
           * @param dirtyList 脏矩形列表
           * @param forRenderTexture 绘制目标是RenderTexture的标志
           * @returns drawCall触发绘制的次数
           */
          WebGLRenderer.prototype.render = function (displayObject, buffer, matrix, forRenderTexture) {
              this.nestLevel++;
              var webglBuffer = buffer;
              var webglBufferContext = webglBuffer.context;
              var root = forRenderTexture ? displayObject : null;
              webglBufferContext.pushBuffer(webglBuffer);
              //绘制显示对象
              webglBuffer.transform(matrix.a, matrix.b, matrix.c, matrix.d, 0, 0);
              this.drawDisplayObject(displayObject, webglBuffer, matrix.tx, matrix.ty, true);
              webglBufferContext.$drawWebGL();
              var drawCall = webglBuffer.$drawCalls;
              webglBuffer.onRenderFinish();
              webglBufferContext.popBuffer();
              var invert = egret.Matrix.create();
              matrix.$invertInto(invert);
              webglBuffer.transform(invert.a, invert.b, invert.c, invert.d, 0, 0);
              egret.Matrix.release(invert);
              this.nestLevel--;
              if (this.nestLevel === 0) {
                  //最大缓存6个渲染缓冲
                  if (renderBufferPool.length > 6) {
                      renderBufferPool.length = 6;
                  }
                  var length_1 = renderBufferPool.length;
                  for (var i = 0; i < length_1; i++) {
                      renderBufferPool[i].resize(0, 0);
                  }
              }
              return drawCall;
          };
          /**
           * @private
           * 绘制一个显示对象
           */
          WebGLRenderer.prototype.drawDisplayObject = function (displayObject, buffer, offsetX, offsetY, isStage) {
              var drawCalls = 0;
              var node;
              var displayList = displayObject.$displayList;
              var hasRednerNode;
              var needDrawToSurface = !!(displayList && !isStage);
              if (needDrawToSurface) {
                  if (displayObject.$cacheDirty || displayObject.$renderDirty ||
                      displayList.$canvasScaleX != egret.sys.DisplayList.$canvasScaleX ||
                      displayList.$canvasScaleY != egret.sys.DisplayList.$canvasScaleY) {
                      drawCalls += displayList.drawToSurface();
                  }
                  node = displayList.$renderNode;
                  hasRednerNode = true;
              }
              else {
                  if (displayObject.$renderDirty) {
                      node = displayObject.$getRenderNode();
                  }
                  else {
                      node = displayObject.$renderNode;
                  }
                  hasRednerNode = displayObject.$hasRenderNode;
              }
              displayObject.$cacheDirty = false;
              if (hasRednerNode) {
                  drawCalls++;
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  if (node.type == 6 /* NormalBitmapNode */) {
                      this.renderNormalBitmap(node, buffer);
                  }
                  else if (node.type == 1 /* BitmapNode */) {
                      this.renderBitmap(node, buffer);
                  }
                  else if (node.type == 2 /* TextNode */) {
                      this.renderText(node, buffer);
                  }
                  else if (node.type == 3 /* GraphicsNode */) {
                      this.renderGraphics(node, buffer);
                  }
                  else if (node.type == 4 /* GroupNode */) {
                      this.renderGroup(node, buffer);
                  }
                  else if (5 /* MeshNode */) {
                      this.renderMesh(node, buffer);
                  }
                  buffer.$offsetX = 0;
                  buffer.$offsetY = 0;
              }
              if (needDrawToSurface) {
                  return drawCalls;
              }
              var children = displayObject.$children;
              if (displayObject.$hasChildren) {
                  var length_2 = children.length;
                  for (var i = 0; i < length_2; i++) {
                      var child = children[i];
                      var offsetX2 = void 0;
                      var offsetY2 = void 0;
                      var tempAlpha = void 0;
                      if (child.$alpha != 1) {
                          tempAlpha = buffer.globalAlpha;
                          buffer.globalAlpha *= child.$alpha;
                      }
                      var savedMatrix = void 0;
                      if (child.$useTranslate) {
                          var m = child.$getMatrix();
                          offsetX2 = offsetX + child.$x;
                          offsetY2 = offsetY + child.$y;
                          var m2 = buffer.globalMatrix;
                          savedMatrix = egret.Matrix.create();
                          savedMatrix.a = m2.a;
                          savedMatrix.b = m2.b;
                          savedMatrix.c = m2.c;
                          savedMatrix.d = m2.d;
                          savedMatrix.tx = m2.tx;
                          savedMatrix.ty = m2.ty;
                          buffer.transform(m.a, m.b, m.c, m.d, offsetX2, offsetY2);
                          offsetX2 = -child.$anchorOffsetX;
                          offsetY2 = -child.$anchorOffsetY;
                      }
                      else {
                          offsetX2 = offsetX + child.$x;
                          offsetY2 = offsetY + child.$y;
                          if (child.$hasAnchor) {
                              offsetX2 -= child.$anchorOffsetX;
                              offsetY2 -= child.$anchorOffsetY;
                          }
                      }
                      if (child.$renderMode === 1 /* DEFAULT */) {
                          drawCalls += this.drawDisplayObject(child, buffer, offsetX2, offsetY2);
                      }
                      else if (child.$renderMode === 3 /* FILTER */) {
                          drawCalls += this.drawWithFilter(child, buffer, offsetX2, offsetY2);
                      }
                      else if (child.$renderMode === 4 /* CLIP */) {
                          drawCalls += this.drawWithClip(child, buffer, offsetX2, offsetY2);
                      }
                      else if (child.$renderMode === 5 /* SCROLLRECT */) {
                          drawCalls += this.drawWithScrollRect(child, buffer, offsetX2, offsetY2);
                      }
                      if (tempAlpha) {
                          buffer.globalAlpha = tempAlpha;
                      }
                      if (savedMatrix) {
                          var m = buffer.globalMatrix;
                          m.a = savedMatrix.a;
                          m.b = savedMatrix.b;
                          m.c = savedMatrix.c;
                          m.d = savedMatrix.d;
                          m.tx = savedMatrix.tx;
                          m.ty = savedMatrix.ty;
                          egret.Matrix.release(savedMatrix);
                      }
                  }
              }
              return drawCalls;
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.drawWithFilter = function (displayObject, buffer, offsetX, offsetY) {
              var drawCalls = 0;
              if (displayObject.$children && displayObject.$children.length == 0 && (!displayObject.$renderNode || displayObject.$renderNode.$getRenderCount() == 0)) {
                  return drawCalls;
              }
              var filters = displayObject.$filters;
              var hasBlendMode = (displayObject.$blendMode !== 0);
              var compositeOp;
              if (hasBlendMode) {
                  compositeOp = blendModes[displayObject.$blendMode];
                  if (!compositeOp) {
                      compositeOp = defaultCompositeOp;
                  }
              }
              var displayBounds = displayObject.$getOriginalBounds();
              var displayBoundsX = displayBounds.x;
              var displayBoundsY = displayBounds.y;
              var displayBoundsWidth = displayBounds.width;
              var displayBoundsHeight = displayBounds.height;
              if (displayBoundsWidth <= 0 || displayBoundsHeight <= 0) {
                  return drawCalls;
              }
              if (!displayObject.mask && filters.length == 1 && (filters[0].type == "colorTransform" || (filters[0].type === "custom" && filters[0].padding === 0))) {
                  var childrenDrawCount = this.getRenderCount(displayObject);
                  if (!displayObject.$children || childrenDrawCount == 1) {
                      if (hasBlendMode) {
                          buffer.context.setGlobalCompositeOperation(compositeOp);
                      }
                      buffer.context.$filter = filters[0];
                      if (displayObject.$mask) {
                          drawCalls += this.drawWithClip(displayObject, buffer, offsetX, offsetY);
                      }
                      else if (displayObject.$scrollRect || displayObject.$maskRect) {
                          drawCalls += this.drawWithScrollRect(displayObject, buffer, offsetX, offsetY);
                      }
                      else {
                          drawCalls += this.drawDisplayObject(displayObject, buffer, offsetX, offsetY);
                      }
                      buffer.context.$filter = null;
                      if (hasBlendMode) {
                          buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
                      }
                      return drawCalls;
                  }
              }
              // 为显示对象创建一个新的buffer
              var displayBuffer = this.createRenderBuffer(displayBoundsWidth, displayBoundsHeight);
              displayBuffer.context.pushBuffer(displayBuffer);
              //todo 可以优化减少draw次数
              if (displayObject.$mask) {
                  drawCalls += this.drawWithClip(displayObject, displayBuffer, -displayBoundsX, -displayBoundsY);
              }
              else if (displayObject.$scrollRect || displayObject.$maskRect) {
                  drawCalls += this.drawWithScrollRect(displayObject, displayBuffer, -displayBoundsX, -displayBoundsY);
              }
              else {
                  drawCalls += this.drawDisplayObject(displayObject, displayBuffer, -displayBoundsX, -displayBoundsY);
              }
              displayBuffer.context.popBuffer();
              //绘制结果到屏幕
              if (drawCalls > 0) {
                  if (hasBlendMode) {
                      buffer.context.setGlobalCompositeOperation(compositeOp);
                  }
                  drawCalls++;
                  // 绘制结果的时候，应用滤镜
                  buffer.$offsetX = offsetX + displayBoundsX;
                  buffer.$offsetY = offsetY + displayBoundsY;
                  var savedMatrix = egret.Matrix.create();
                  var curMatrix = buffer.globalMatrix;
                  savedMatrix.a = curMatrix.a;
                  savedMatrix.b = curMatrix.b;
                  savedMatrix.c = curMatrix.c;
                  savedMatrix.d = curMatrix.d;
                  savedMatrix.tx = curMatrix.tx;
                  savedMatrix.ty = curMatrix.ty;
                  buffer.useOffset();
                  buffer.context.drawTargetWidthFilters(filters, displayBuffer);
                  curMatrix.a = savedMatrix.a;
                  curMatrix.b = savedMatrix.b;
                  curMatrix.c = savedMatrix.c;
                  curMatrix.d = savedMatrix.d;
                  curMatrix.tx = savedMatrix.tx;
                  curMatrix.ty = savedMatrix.ty;
                  egret.Matrix.release(savedMatrix);
                  if (hasBlendMode) {
                      buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
                  }
              }
              renderBufferPool.push(displayBuffer);
              return drawCalls;
          };
          WebGLRenderer.prototype.getRenderCount = function (displayObject) {
              var drawCount = 0;
              var node = displayObject.$getRenderNode();
              if (displayObject.$hasRenderNode) {
                  drawCount += node.$getRenderCount();
              }
              if (displayObject.$children) {
                  for (var _i = 0, _a = displayObject.$children; _i < _a.length; _i++) {
                      var child = _a[_i];
                      var filters = child.$filters;
                      // 特殊处理有滤镜的对象
                      if (filters && filters.length > 0) {
                          return 2;
                      }
                      else if (child.$children) {
                          drawCount += this.getRenderCount(child);
                      }
                      else {
                          var node_1 = child.$getRenderNode();
                          if (child.$hasRenderNode) {
                              drawCount += node_1.$getRenderCount();
                          }
                      }
                  }
              }
              return drawCount;
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.drawWithClip = function (displayObject, buffer, offsetX, offsetY) {
              var drawCalls = 0;
              var hasBlendMode = (displayObject.$blendMode !== 0);
              var compositeOp;
              if (hasBlendMode) {
                  compositeOp = blendModes[displayObject.$blendMode];
                  if (!compositeOp) {
                      compositeOp = defaultCompositeOp;
                  }
              }
              var scrollRect = displayObject.$scrollRect ? displayObject.$scrollRect : displayObject.$maskRect;
              var mask = displayObject.$mask;
              if (mask) {
                  var maskRenderMatrix = mask.$getMatrix();
                  //遮罩scaleX或scaleY为0，放弃绘制
                  if ((maskRenderMatrix.a == 0 && maskRenderMatrix.b == 0) || (maskRenderMatrix.c == 0 && maskRenderMatrix.d == 0)) {
                      return drawCalls;
                  }
              }
              //没有遮罩,同时显示对象没有子项
              if (!mask && (!displayObject.$children || displayObject.$children.length == 0)) {
                  if (scrollRect) {
                      buffer.context.pushMask(scrollRect.x + offsetX, scrollRect.y + offsetY, scrollRect.width, scrollRect.height);
                  }
                  //绘制显示对象
                  if (hasBlendMode) {
                      buffer.context.setGlobalCompositeOperation(compositeOp);
                  }
                  drawCalls += this.drawDisplayObject(displayObject, buffer, offsetX, offsetY);
                  if (hasBlendMode) {
                      buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
                  }
                  if (scrollRect) {
                      buffer.context.popMask();
                  }
                  return drawCalls;
              }
              else {
                  var displayBounds = displayObject.$getOriginalBounds();
                  var displayBoundsX = displayBounds.x;
                  var displayBoundsY = displayBounds.y;
                  var displayBoundsWidth = displayBounds.width;
                  var displayBoundsHeight = displayBounds.height;
                  //绘制显示对象自身，若有scrollRect，应用clip
                  var displayBuffer = this.createRenderBuffer(displayBoundsWidth, displayBoundsHeight);
                  displayBuffer.context.pushBuffer(displayBuffer);
                  drawCalls += this.drawDisplayObject(displayObject, displayBuffer, -displayBoundsX, -displayBoundsY);
                  //绘制遮罩
                  if (mask) {
                      var maskBuffer = this.createRenderBuffer(displayBoundsWidth, displayBoundsHeight);
                      maskBuffer.context.pushBuffer(maskBuffer);
                      var maskMatrix = egret.Matrix.create();
                      maskMatrix.copyFrom(mask.$getConcatenatedMatrix());
                      mask.$getConcatenatedMatrixAt(displayObject, maskMatrix);
                      maskMatrix.translate(-displayBoundsX, -displayBoundsY);
                      maskBuffer.setTransform(maskMatrix.a, maskMatrix.b, maskMatrix.c, maskMatrix.d, maskMatrix.tx, maskMatrix.ty);
                      egret.Matrix.release(maskMatrix);
                      drawCalls += this.drawDisplayObject(mask, maskBuffer, 0, 0);
                      maskBuffer.context.popBuffer();
                      displayBuffer.context.setGlobalCompositeOperation("destination-in");
                      displayBuffer.setTransform(1, 0, 0, -1, 0, maskBuffer.height);
                      var maskBufferWidth = maskBuffer.rootRenderTarget.width;
                      var maskBufferHeight = maskBuffer.rootRenderTarget.height;
                      displayBuffer.context.drawTexture(maskBuffer.rootRenderTarget.texture, 0, 0, maskBufferWidth, maskBufferHeight, 0, 0, maskBufferWidth, maskBufferHeight, maskBufferWidth, maskBufferHeight);
                      displayBuffer.setTransform(1, 0, 0, 1, 0, 0);
                      displayBuffer.context.setGlobalCompositeOperation("source-over");
                      maskBuffer.setTransform(1, 0, 0, 1, 0, 0);
                      renderBufferPool.push(maskBuffer);
                  }
                  displayBuffer.context.setGlobalCompositeOperation(defaultCompositeOp);
                  displayBuffer.context.popBuffer();
                  //绘制结果到屏幕
                  if (drawCalls > 0) {
                      drawCalls++;
                      if (hasBlendMode) {
                          buffer.context.setGlobalCompositeOperation(compositeOp);
                      }
                      if (scrollRect) {
                          buffer.context.pushMask(scrollRect.x + offsetX, scrollRect.y + offsetY, scrollRect.width, scrollRect.height);
                      }
                      var savedMatrix = egret.Matrix.create();
                      var curMatrix = buffer.globalMatrix;
                      savedMatrix.a = curMatrix.a;
                      savedMatrix.b = curMatrix.b;
                      savedMatrix.c = curMatrix.c;
                      savedMatrix.d = curMatrix.d;
                      savedMatrix.tx = curMatrix.tx;
                      savedMatrix.ty = curMatrix.ty;
                      curMatrix.append(1, 0, 0, -1, offsetX + displayBoundsX, offsetY + displayBoundsY + displayBuffer.height);
                      var displayBufferWidth = displayBuffer.rootRenderTarget.width;
                      var displayBufferHeight = displayBuffer.rootRenderTarget.height;
                      buffer.context.drawTexture(displayBuffer.rootRenderTarget.texture, 0, 0, displayBufferWidth, displayBufferHeight, 0, 0, displayBufferWidth, displayBufferHeight, displayBufferWidth, displayBufferHeight);
                      if (scrollRect) {
                          displayBuffer.context.popMask();
                      }
                      if (hasBlendMode) {
                          buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
                      }
                      var matrix = buffer.globalMatrix;
                      matrix.a = savedMatrix.a;
                      matrix.b = savedMatrix.b;
                      matrix.c = savedMatrix.c;
                      matrix.d = savedMatrix.d;
                      matrix.tx = savedMatrix.tx;
                      matrix.ty = savedMatrix.ty;
                      egret.Matrix.release(savedMatrix);
                  }
                  renderBufferPool.push(displayBuffer);
                  return drawCalls;
              }
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.drawWithScrollRect = function (displayObject, buffer, offsetX, offsetY) {
              var drawCalls = 0;
              var scrollRect = displayObject.$scrollRect ? displayObject.$scrollRect : displayObject.$maskRect;
              if (scrollRect.isEmpty()) {
                  return drawCalls;
              }
              if (displayObject.$scrollRect) {
                  offsetX -= scrollRect.x;
                  offsetY -= scrollRect.y;
              }
              var m = buffer.globalMatrix;
              var context = buffer.context;
              var scissor = false;
              if (buffer.$hasScissor || m.b != 0 || m.c != 0) {
                  buffer.context.pushMask(scrollRect.x + offsetX, scrollRect.y + offsetY, scrollRect.width, scrollRect.height);
              }
              else {
                  var a = m.a;
                  var d = m.d;
                  var tx = m.tx;
                  var ty = m.ty;
                  var x = scrollRect.x + offsetX;
                  var y = scrollRect.y + offsetY;
                  var xMax = x + scrollRect.width;
                  var yMax = y + scrollRect.height;
                  var minX = void 0, minY = void 0, maxX = void 0, maxY = void 0;
                  //优化，通常情况下不缩放的对象占多数，直接加上偏移量即可。
                  if (a == 1.0 && d == 1.0) {
                      minX = x + tx;
                      minY = y + ty;
                      maxX = xMax + tx;
                      maxY = yMax + ty;
                  }
                  else {
                      var x0 = a * x + tx;
                      var y0 = d * y + ty;
                      var x1 = a * xMax + tx;
                      var y1 = d * y + ty;
                      var x2 = a * xMax + tx;
                      var y2 = d * yMax + ty;
                      var x3 = a * x + tx;
                      var y3 = d * yMax + ty;
                      var tmp = 0;
                      if (x0 > x1) {
                          tmp = x0;
                          x0 = x1;
                          x1 = tmp;
                      }
                      if (x2 > x3) {
                          tmp = x2;
                          x2 = x3;
                          x3 = tmp;
                      }
                      minX = (x0 < x2 ? x0 : x2);
                      maxX = (x1 > x3 ? x1 : x3);
                      if (y0 > y1) {
                          tmp = y0;
                          y0 = y1;
                          y1 = tmp;
                      }
                      if (y2 > y3) {
                          tmp = y2;
                          y2 = y3;
                          y3 = tmp;
                      }
                      minY = (y0 < y2 ? y0 : y2);
                      maxY = (y1 > y3 ? y1 : y3);
                  }
                  context.enableScissor(minX, -maxY + buffer.height, maxX - minX, maxY - minY);
                  scissor = true;
              }
              drawCalls += this.drawDisplayObject(displayObject, buffer, offsetX, offsetY);
              if (scissor) {
                  context.disableScissor();
              }
              else {
                  context.popMask();
              }
              return drawCalls;
          };
          /**
           * 将一个RenderNode对象绘制到渲染缓冲
           * @param node 要绘制的节点
           * @param buffer 渲染缓冲
           * @param matrix 要叠加的矩阵
           * @param forHitTest 绘制结果是用于碰撞检测。若为true，当渲染GraphicsNode时，会忽略透明度样式设置，全都绘制为不透明的。
           */
          WebGLRenderer.prototype.drawNodeToBuffer = function (node, buffer, matrix, forHitTest) {
              var webglBuffer = buffer;
              //pushRenderTARGET
              webglBuffer.context.pushBuffer(webglBuffer);
              webglBuffer.setTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty);
              this.renderNode(node, buffer, 0, 0, forHitTest);
              webglBuffer.context.$drawWebGL();
              webglBuffer.onRenderFinish();
              //popRenderTARGET
              webglBuffer.context.popBuffer();
          };
          /**
           * 将一个DisplayObject绘制到渲染缓冲，用于RenderTexture绘制
           * @param displayObject 要绘制的显示对象
           * @param buffer 渲染缓冲
           * @param matrix 要叠加的矩阵
           */
          WebGLRenderer.prototype.drawDisplayToBuffer = function (displayObject, buffer, matrix) {
              buffer.context.pushBuffer(buffer);
              if (matrix) {
                  buffer.setTransform(matrix.a, matrix.b, matrix.c, matrix.d, matrix.tx, matrix.ty);
              }
              var node;
              if (displayObject.$renderDirty) {
                  node = displayObject.$getRenderNode();
              }
              else {
                  node = displayObject.$renderNode;
              }
              var drawCalls = 0;
              if (displayObject.$hasRenderNode) {
                  drawCalls++;
                  if (node.type == 6 /* NormalBitmapNode */) {
                      this.renderNormalBitmap(node, buffer);
                  }
                  else if (node.type == 1 /* BitmapNode */) {
                      this.renderBitmap(node, buffer);
                  }
                  else if (node.type == 2 /* TextNode */) {
                      this.renderText(node, buffer);
                  }
                  else if (node.type == 3 /* GraphicsNode */) {
                      this.renderGraphics(node, buffer);
                  }
                  else if (node.type == 4 /* GroupNode */) {
                      this.renderGroup(node, buffer);
                  }
                  else if (node.type == 5 /* MeshNode */) {
                      this.renderMesh(node, buffer);
                  }
              }
              var children = displayObject.$children;
              if (children) {
                  var length_3 = children.length;
                  for (var i = 0; i < length_3; i++) {
                      var child = children[i];
                      if (child.$renderMode === 1 /* DEFAULT */) {
                          drawCalls += this.drawDisplayObject(child, buffer, 0, 0);
                      }
                      else if (child.$renderMode === 3 /* FILTER */) {
                          drawCalls += this.drawWithFilter(child, buffer, 0, 0);
                      }
                      else if (child.$renderMode === 4 /* CLIP */) {
                          drawCalls += this.drawWithClip(child, buffer, 0, 0);
                      }
                      else if (child.$renderMode === 5 /* SCROLLRECT */) {
                          drawCalls += this.drawWithScrollRect(child, buffer, 0, 0);
                      }
                  }
              }
              buffer.context.$drawWebGL();
              buffer.onRenderFinish();
              buffer.context.popBuffer();
              return drawCalls;
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderNode = function (node, buffer, offsetX, offsetY, forHitTest) {
              buffer.$offsetX = offsetX;
              buffer.$offsetY = offsetY;
              if (node.type == 6 /* NormalBitmapNode */) {
                  this.renderNormalBitmap(node, buffer);
              }
              else if (node.type == 1 /* BitmapNode */) {
                  this.renderBitmap(node, buffer);
              }
              else if (node.type == 2 /* TextNode */) {
                  this.renderText(node, buffer);
              }
              else if (node.type == 3 /* GraphicsNode */) {
                  this.renderGraphics(node, buffer, forHitTest);
              }
              else if (node.type == 4 /* GroupNode */) {
                  this.renderGroup(node, buffer);
              }
              else if (node.type == 5 /* MeshNode */) {
                  this.renderMesh(node, buffer);
              }
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderNormalBitmap = function (node, buffer) {
              var image = node.image;
              if (!image) {
                  return;
              }
              buffer.context.drawImageByRenderNode(node);
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderBitmap = function (node, buffer) {
              var image = node.image;
              if (!image) {
                  return;
              }
              //buffer.imageSmoothingEnabled = node.smoothing;
              var data = node.drawData;
              var length = data.length;
              var pos = 0;
              var m = node.matrix;
              var blendMode = node.blendMode;
              var alpha = node.alpha;
              var savedMatrix;
              var offsetX;
              var offsetY;
              if (m) {
                  savedMatrix = egret.Matrix.create();
                  var curMatrix = buffer.globalMatrix;
                  savedMatrix.a = curMatrix.a;
                  savedMatrix.b = curMatrix.b;
                  savedMatrix.c = curMatrix.c;
                  savedMatrix.d = curMatrix.d;
                  savedMatrix.tx = curMatrix.tx;
                  savedMatrix.ty = curMatrix.ty;
                  offsetX = buffer.$offsetX;
                  offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(m.a, m.b, m.c, m.d, m.tx, m.ty);
              }
              //这里不考虑嵌套
              if (blendMode) {
                  buffer.context.setGlobalCompositeOperation(blendModes[blendMode]);
              }
              var originAlpha;
              if (alpha == alpha) {
                  originAlpha = buffer.globalAlpha;
                  buffer.globalAlpha *= alpha;
              }
              if (node.filter) {
                  buffer.context.$filter = node.filter;
                  while (pos < length) {
                      buffer.context.drawImage(image, data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], node.imageWidth, node.imageHeight, node.rotated, node.smoothing);
                  }
                  buffer.context.$filter = null;
              }
              else {
                  while (pos < length) {
                      buffer.context.drawImage(image, data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], node.imageWidth, node.imageHeight, node.rotated, node.smoothing);
                  }
              }
              if (blendMode) {
                  buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
              }
              if (alpha == alpha) {
                  buffer.globalAlpha = originAlpha;
              }
              if (m) {
                  var matrix = buffer.globalMatrix;
                  matrix.a = savedMatrix.a;
                  matrix.b = savedMatrix.b;
                  matrix.c = savedMatrix.c;
                  matrix.d = savedMatrix.d;
                  matrix.tx = savedMatrix.tx;
                  matrix.ty = savedMatrix.ty;
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  egret.Matrix.release(savedMatrix);
              }
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderMesh = function (node, buffer) {
              var image = node.image;
              //buffer.imageSmoothingEnabled = node.smoothing;
              var data = node.drawData;
              var length = data.length;
              var pos = 0;
              var m = node.matrix;
              var blendMode = node.blendMode;
              var alpha = node.alpha;
              var savedMatrix;
              var offsetX;
              var offsetY;
              if (m) {
                  savedMatrix = egret.Matrix.create();
                  var curMatrix = buffer.globalMatrix;
                  savedMatrix.a = curMatrix.a;
                  savedMatrix.b = curMatrix.b;
                  savedMatrix.c = curMatrix.c;
                  savedMatrix.d = curMatrix.d;
                  savedMatrix.tx = curMatrix.tx;
                  savedMatrix.ty = curMatrix.ty;
                  offsetX = buffer.$offsetX;
                  offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(m.a, m.b, m.c, m.d, m.tx, m.ty);
              }
              //这里不考虑嵌套
              if (blendMode) {
                  buffer.context.setGlobalCompositeOperation(blendModes[blendMode]);
              }
              var originAlpha;
              if (alpha == alpha) {
                  originAlpha = buffer.globalAlpha;
                  buffer.globalAlpha *= alpha;
              }
              if (node.filter) {
                  buffer.context.$filter = node.filter;
                  while (pos < length) {
                      buffer.context.drawMesh(image, data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], node.imageWidth, node.imageHeight, node.uvs, node.vertices, node.indices, node.bounds, node.rotated, node.smoothing);
                  }
                  buffer.context.$filter = null;
              }
              else {
                  while (pos < length) {
                      buffer.context.drawMesh(image, data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], data[pos++], node.imageWidth, node.imageHeight, node.uvs, node.vertices, node.indices, node.bounds, node.rotated, node.smoothing);
                  }
              }
              if (blendMode) {
                  buffer.context.setGlobalCompositeOperation(defaultCompositeOp);
              }
              if (alpha == alpha) {
                  buffer.globalAlpha = originAlpha;
              }
              if (m) {
                  var matrix = buffer.globalMatrix;
                  matrix.a = savedMatrix.a;
                  matrix.b = savedMatrix.b;
                  matrix.c = savedMatrix.c;
                  matrix.d = savedMatrix.d;
                  matrix.tx = savedMatrix.tx;
                  matrix.ty = savedMatrix.ty;
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  egret.Matrix.release(savedMatrix);
              }
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderText = function (node, buffer) {
              var width = node.width - node.x;
              var height = node.height - node.y;
              if (width <= 0 || height <= 0 || !width || !height || node.drawData.length == 0) {
                  return;
              }
              var canvasScaleX = egret.sys.DisplayList.$canvasScaleX;
              var canvasScaleY = egret.sys.DisplayList.$canvasScaleY;
              var maxTextureSize = buffer.context.$maxTextureSize;
              if (width * canvasScaleX > maxTextureSize) {
                  canvasScaleX *= maxTextureSize / (width * canvasScaleX);
              }
              if (height * canvasScaleY > maxTextureSize) {
                  canvasScaleY *= maxTextureSize / (height * canvasScaleY);
              }
              width *= canvasScaleX;
              height *= canvasScaleY;
              var x = node.x * canvasScaleX;
              var y = node.y * canvasScaleY;
              if (node.$canvasScaleX != canvasScaleX || node.$canvasScaleY != canvasScaleY) {
                  node.$canvasScaleX = canvasScaleX;
                  node.$canvasScaleY = canvasScaleY;
                  node.dirtyRender = true;
              }
              if (!this.canvasRenderBuffer || !this.canvasRenderBuffer.context) {
                  this.canvasRenderer = new egret.CanvasRenderer();
                  this.canvasRenderBuffer = new wxgame.CanvasRenderBuffer(width, height);
              }
              else if (node.dirtyRender) {
                  this.canvasRenderBuffer.resize(width, height);
              }
              if (!this.canvasRenderBuffer.context) {
                  return;
              }
              if (canvasScaleX != 1 || canvasScaleY != 1) {
                  this.canvasRenderBuffer.context.setTransform(canvasScaleX, 0, 0, canvasScaleY, 0, 0);
              }
              if (x || y) {
                  if (node.dirtyRender) {
                      this.canvasRenderBuffer.context.setTransform(canvasScaleX, 0, 0, canvasScaleY, -x, -y);
                  }
                  buffer.transform(1, 0, 0, 1, x / canvasScaleX, y / canvasScaleY);
              }
              else if (canvasScaleX != 1 || canvasScaleY != 1) {
                  this.canvasRenderBuffer.context.setTransform(canvasScaleX, 0, 0, canvasScaleY, 0, 0);
              }
              if (node.dirtyRender) {
                  var surface = this.canvasRenderBuffer.surface;
                  this.canvasRenderer.renderText(node, this.canvasRenderBuffer.context);
                  // 拷贝canvas到texture
                  var texture = node.$texture;
                  if (!texture) {
                      texture = buffer.context.createTexture(surface);
                      node.$texture = texture;
                  }
                  else {
                      // 重新拷贝新的图像
                      buffer.context.updateTexture(texture, surface);
                  }
                  // 保存材质尺寸
                  node.$textureWidth = surface.width;
                  node.$textureHeight = surface.height;
              }
              buffer.context.drawTextureByRenderNode(node);
              if (x || y) {
                  if (node.dirtyRender) {
                      this.canvasRenderBuffer.context.setTransform(canvasScaleX, 0, 0, canvasScaleY, 0, 0);
                  }
                  buffer.transform(1, 0, 0, 1, -x / canvasScaleX, -y / canvasScaleY);
              }
              node.dirtyRender = false;
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.renderGraphics = function (node, buffer, forHitTest) {
              var width = node.width;
              var height = node.height;
              if (width <= 0 || height <= 0 || !width || !height || node.drawData.length == 0) {
                  return;
              }
              var canvasScaleX = egret.sys.DisplayList.$canvasScaleX;
              var canvasScaleY = egret.sys.DisplayList.$canvasScaleY;
              if (width * canvasScaleX < 1 || height * canvasScaleY < 1) {
                  canvasScaleX = canvasScaleY = 1;
              }
              if (node.$canvasScaleX != canvasScaleX || node.$canvasScaleY != canvasScaleY) {
                  node.$canvasScaleX = canvasScaleX;
                  node.$canvasScaleY = canvasScaleY;
                  node.dirtyRender = true;
              }
              //缩放叠加 width2 / width 填满整个区域
              width = width * canvasScaleX;
              height = height * canvasScaleY;
              var width2 = Math.ceil(width);
              var height2 = Math.ceil(height);
              canvasScaleX *= width2 / width;
              canvasScaleY *= height2 / height;
              width = width2;
              height = height2;
              if (!this.canvasRenderBuffer || !this.canvasRenderBuffer.context) {
                  this.canvasRenderer = new egret.CanvasRenderer();
                  this.canvasRenderBuffer = new wxgame.CanvasRenderBuffer(width, height);
              }
              else if (node.dirtyRender || forHitTest) {
                  this.canvasRenderBuffer.resize(width, height);
              }
              if (!this.canvasRenderBuffer.context) {
                  return;
              }
              if (canvasScaleX != 1 || canvasScaleY != 1) {
                  this.canvasRenderBuffer.context.setTransform(canvasScaleX, 0, 0, canvasScaleY, 0, 0);
              }
              if (node.x || node.y) {
                  if (node.dirtyRender || forHitTest) {
                      this.canvasRenderBuffer.context.translate(-node.x, -node.y);
                  }
                  buffer.transform(1, 0, 0, 1, node.x, node.y);
              }
              var surface = this.canvasRenderBuffer.surface;
              if (forHitTest) {
                  this.canvasRenderer.renderGraphics(node, this.canvasRenderBuffer.context, true);
                  egret.WebGLUtils.deleteWebGLTexture(surface);
                  var texture = buffer.context.getWebGLTexture(surface);
                  buffer.context.drawTexture(texture, 0, 0, width, height, 0, 0, width, height, surface.width, surface.height);
              }
              else {
                  if (node.dirtyRender) {
                      this.canvasRenderer.renderGraphics(node, this.canvasRenderBuffer.context);
                      // 拷贝canvas到texture
                      var texture = node.$texture;
                      if (!texture) {
                          texture = buffer.context.createTexture(surface);
                          node.$texture = texture;
                      }
                      else {
                          // 重新拷贝新的图像
                          buffer.context.updateTexture(texture, surface);
                      }
                      // 保存材质尺寸
                      node.$textureWidth = surface.width;
                      node.$textureHeight = surface.height;
                  }
                  // buffer.context.drawTexture(node.$texture, 0, 0, node.$textureWidth, node.$textureHeight, 0, 0,
                  //     node.$textureWidth / canvasScaleX, node.$textureHeight / canvasScaleY, node.$textureWidth, node.$textureHeight);
                  buffer.context.drawTextureByRenderNode(node);
              }
              if (node.x || node.y) {
                  if (node.dirtyRender || forHitTest) {
                      this.canvasRenderBuffer.context.translate(node.x, node.y);
                  }
                  buffer.transform(1, 0, 0, 1, -node.x, -node.y);
              }
              if (!forHitTest) {
                  node.dirtyRender = false;
              }
          };
          WebGLRenderer.prototype.renderGroup = function (groupNode, buffer) {
              var m = groupNode.matrix;
              var savedMatrix;
              var offsetX;
              var offsetY;
              if (m) {
                  savedMatrix = egret.Matrix.create();
                  var curMatrix = buffer.globalMatrix;
                  savedMatrix.a = curMatrix.a;
                  savedMatrix.b = curMatrix.b;
                  savedMatrix.c = curMatrix.c;
                  savedMatrix.d = curMatrix.d;
                  savedMatrix.tx = curMatrix.tx;
                  savedMatrix.ty = curMatrix.ty;
                  offsetX = buffer.$offsetX;
                  offsetY = buffer.$offsetY;
                  buffer.useOffset();
                  buffer.transform(m.a, m.b, m.c, m.d, m.tx, m.ty);
              }
              var children = groupNode.drawData;
              var length = children.length;
              for (var i = 0; i < length; i++) {
                  var node = children[i];
                  this.renderNode(node, buffer, buffer.$offsetX, buffer.$offsetY);
              }
              if (m) {
                  var matrix = buffer.globalMatrix;
                  matrix.a = savedMatrix.a;
                  matrix.b = savedMatrix.b;
                  matrix.c = savedMatrix.c;
                  matrix.d = savedMatrix.d;
                  matrix.tx = savedMatrix.tx;
                  matrix.ty = savedMatrix.ty;
                  buffer.$offsetX = offsetX;
                  buffer.$offsetY = offsetY;
                  egret.Matrix.release(savedMatrix);
              }
          };
          /**
           * @private
           */
          WebGLRenderer.prototype.createRenderBuffer = function (width, height) {
              var buffer = renderBufferPool.pop();
              if (buffer) {
                  buffer.resize(width, height);
              }
              else {
                  buffer = new wxgame.WebGLRenderBuffer(width, height);
                  buffer.$computeDrawCall = false;
              }
              return buffer;
          };
          return WebGLRenderer;
      }());
      wxgame.WebGLRenderer = WebGLRenderer;
      __reflect(WebGLRenderer.prototype, "egret.wxgame.WebGLRenderer", ["egret.sys.SystemRenderer"]);
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WEBGL_ATTRIBUTE_TYPE;
      (function (WEBGL_ATTRIBUTE_TYPE) {
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["FLOAT"] = 5126] = "FLOAT";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["BYTE"] = 65535] = "BYTE";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
          WEBGL_ATTRIBUTE_TYPE[WEBGL_ATTRIBUTE_TYPE["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
      })(WEBGL_ATTRIBUTE_TYPE = wxgame.WEBGL_ATTRIBUTE_TYPE || (wxgame.WEBGL_ATTRIBUTE_TYPE = {}));
      /**
       * @private
       */
      var EgretWebGLAttribute = (function () {
          function EgretWebGLAttribute(gl, program, attributeData) {
              this.gl = gl;
              this.name = attributeData.name;
              this.type = attributeData.type;
              this.size = attributeData.size;
              this.location = gl.getAttribLocation(program, this.name);
              this.count = 0;
              this.initCount(gl);
              this.format = gl.FLOAT;
              this.initFormat(gl);
          }
          EgretWebGLAttribute.prototype.initCount = function (gl) {
              var type = this.type;
              switch (type) {
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT:
                  case WEBGL_ATTRIBUTE_TYPE.BYTE:
                  case WEBGL_ATTRIBUTE_TYPE.UNSIGNED_BYTE:
                  case WEBGL_ATTRIBUTE_TYPE.UNSIGNED_SHORT:
                      this.count = 1;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC2:
                      this.count = 2;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC3:
                      this.count = 3;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC4:
                      this.count = 4;
                      break;
              }
          };
          EgretWebGLAttribute.prototype.initFormat = function (gl) {
              var type = this.type;
              switch (type) {
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT:
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC2:
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC3:
                  case WEBGL_ATTRIBUTE_TYPE.FLOAT_VEC4:
                      this.format = gl.FLOAT;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.UNSIGNED_BYTE:
                      this.format = gl.UNSIGNED_BYTE;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.UNSIGNED_SHORT:
                      this.format = gl.UNSIGNED_SHORT;
                      break;
                  case WEBGL_ATTRIBUTE_TYPE.BYTE:
                      this.format = gl.BYTE;
                      break;
              }
          };
          return EgretWebGLAttribute;
      }());
      wxgame.EgretWebGLAttribute = EgretWebGLAttribute;
      __reflect(EgretWebGLAttribute.prototype, "egret.wxgame.EgretWebGLAttribute");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      function loadShader(gl, type, source) {
          var shader = gl.createShader(type);
          gl.shaderSource(shader, source);
          gl.compileShader(shader);
          var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
          if (!compiled) {
              console.log("shader not compiled!");
              console.log(gl.getShaderInfoLog(shader));
          }
          return shader;
      }
      function createWebGLProgram(gl, vertexShader, fragmentShader) {
          var program = gl.createProgram();
          gl.attachShader(program, vertexShader);
          gl.attachShader(program, fragmentShader);
          gl.linkProgram(program);
          return program;
      }
      function extractAttributes(gl, program) {
          var attributes = {};
          var totalAttributes = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
          for (var i = 0; i < totalAttributes; i++) {
              var attribData = gl.getActiveAttrib(program, i);
              var name_2 = attribData.name;
              var attribute = new wxgame.EgretWebGLAttribute(gl, program, attribData);
              attributes[name_2] = attribute;
          }
          return attributes;
      }
      function extractUniforms(gl, program) {
          var uniforms = {};
          var totalUniforms = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
          for (var i = 0; i < totalUniforms; i++) {
              var uniformData = gl.getActiveUniform(program, i);
              var name_3 = uniformData.name;
              var uniform = new wxgame.EgretWebGLUniform(gl, program, uniformData);
              uniforms[name_3] = uniform;
          }
          return uniforms;
      }
      /**
       * @private
       */
      var EgretWebGLProgram = (function () {
          function EgretWebGLProgram(gl, vertSource, fragSource) {
              this.vshaderSource = vertSource;
              this.fshaderSource = fragSource;
              this.vertexShader = loadShader(gl, gl.VERTEX_SHADER, this.vshaderSource);
              this.fragmentShader = loadShader(gl, gl.FRAGMENT_SHADER, this.fshaderSource);
              this.id = createWebGLProgram(gl, this.vertexShader, this.fragmentShader);
              this.uniforms = extractUniforms(gl, this.id);
              this.attributes = extractAttributes(gl, this.id);
          }
          /**
           * 获取所需的WebGL Program
           * @param key {string} 对于唯一的program程序，对应唯一的key
           */
          EgretWebGLProgram.getProgram = function (gl, vertSource, fragSource, key) {
              if (!this.programCache[key]) {
                  this.programCache[key] = new EgretWebGLProgram(gl, vertSource, fragSource);
              }
              return this.programCache[key];
          };
          EgretWebGLProgram.deleteProgram = function (gl, vertSource, fragSource, key) {
              // TODO delete
          };
          EgretWebGLProgram.programCache = {};
          return EgretWebGLProgram;
      }());
      wxgame.EgretWebGLProgram = EgretWebGLProgram;
      __reflect(EgretWebGLProgram.prototype, "egret.wxgame.EgretWebGLProgram");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
//////////////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2014-present, Egret Technology.
//  All rights reserved.
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the Egret nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////////////

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var WEBGL_UNIFORM_TYPE;
      (function (WEBGL_UNIFORM_TYPE) {
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["INT_VEC2"] = 35667] = "INT_VEC2";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["INT_VEC3"] = 35668] = "INT_VEC3";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["INT_VEC4"] = 35669] = "INT_VEC4";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["BOOL"] = 35670] = "BOOL";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["SAMPLER_CUBE"] = 35680] = "SAMPLER_CUBE";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["BYTE"] = 65535] = "BYTE";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["SHORT"] = 5122] = "SHORT";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["INT"] = 5124] = "INT";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
          WEBGL_UNIFORM_TYPE[WEBGL_UNIFORM_TYPE["FLOAT"] = 5126] = "FLOAT";
      })(WEBGL_UNIFORM_TYPE = wxgame.WEBGL_UNIFORM_TYPE || (wxgame.WEBGL_UNIFORM_TYPE = {}));
      /**
       * @private
       */
      var EgretWebGLUniform = (function () {
          function EgretWebGLUniform(gl, program, uniformData) {
              this.gl = gl;
              this.name = uniformData.name;
              this.type = uniformData.type;
              this.size = uniformData.size;
              this.location = gl.getUniformLocation(program, this.name);
              this.setDefaultValue();
              this.generateSetValue();
              this.generateUpload();
          }
          EgretWebGLUniform.prototype.setDefaultValue = function () {
              var type = this.type;
              switch (type) {
                  case WEBGL_UNIFORM_TYPE.FLOAT:
                  case WEBGL_UNIFORM_TYPE.SAMPLER_2D:
                  case WEBGL_UNIFORM_TYPE.SAMPLER_CUBE:
                  case WEBGL_UNIFORM_TYPE.BOOL:
                  case WEBGL_UNIFORM_TYPE.INT:
                      this.value = 0;
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC2:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC2:
                  case WEBGL_UNIFORM_TYPE.INT_VEC2:
                      this.value = [0, 0];
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC3:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC3:
                  case WEBGL_UNIFORM_TYPE.INT_VEC3:
                      this.value = [0, 0, 0];
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC4:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC4:
                  case WEBGL_UNIFORM_TYPE.INT_VEC4:
                      this.value = [0, 0, 0, 0];
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT2:
                      this.value = new Float32Array([
                          1, 0,
                          0, 1
                      ]);
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT3:
                      this.value = new Float32Array([
                          1, 0, 0,
                          0, 1, 0,
                          0, 0, 1
                      ]);
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT4:
                      this.value = new Float32Array([
                          1, 0, 0, 0,
                          0, 1, 0, 0,
                          0, 0, 1, 0,
                          0, 0, 0, 1
                      ]);
                      break;
              }
          };
          EgretWebGLUniform.prototype.generateSetValue = function () {
              var type = this.type;
              switch (type) {
                  case WEBGL_UNIFORM_TYPE.FLOAT:
                  case WEBGL_UNIFORM_TYPE.SAMPLER_2D:
                  case WEBGL_UNIFORM_TYPE.SAMPLER_CUBE:
                  case WEBGL_UNIFORM_TYPE.BOOL:
                  case WEBGL_UNIFORM_TYPE.INT:
                      this.setValue = function (value) {
                          var notEqual = this.value !== value;
                          this.value = value;
                          notEqual && this.upload();
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC2:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC2:
                  case WEBGL_UNIFORM_TYPE.INT_VEC2:
                      this.setValue = function (value) {
                          var notEqual = this.value[0] !== value.x || this.value[1] !== value.y;
                          this.value[0] = value.x;
                          this.value[1] = value.y;
                          notEqual && this.upload();
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC3:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC3:
                  case WEBGL_UNIFORM_TYPE.INT_VEC3:
                      this.setValue = function (value) {
                          this.value[0] = value.x;
                          this.value[1] = value.y;
                          this.value[2] = value.z;
                          this.upload();
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC4:
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC4:
                  case WEBGL_UNIFORM_TYPE.INT_VEC4:
                      this.setValue = function (value) {
                          this.value[0] = value.x;
                          this.value[1] = value.y;
                          this.value[2] = value.z;
                          this.value[3] = value.w;
                          this.upload();
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT2:
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT3:
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT4:
                      this.setValue = function (value) {
                          this.value.set(value);
                          this.upload();
                      };
                      break;
              }
          };
          EgretWebGLUniform.prototype.generateUpload = function () {
              var gl = this.gl;
              var type = this.type;
              var location = this.location;
              switch (type) {
                  case WEBGL_UNIFORM_TYPE.FLOAT:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform1f(location, value);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC2:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform2f(location, value[0], value[1]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC3:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform3f(location, value[0], value[1], value[2]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_VEC4:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform4f(location, value[0], value[1], value[2], value[3]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.SAMPLER_2D:
                  case WEBGL_UNIFORM_TYPE.SAMPLER_CUBE:
                  case WEBGL_UNIFORM_TYPE.BOOL:
                  case WEBGL_UNIFORM_TYPE.INT:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform1i(location, value);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC2:
                  case WEBGL_UNIFORM_TYPE.INT_VEC2:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform2i(location, value[0], value[1]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC3:
                  case WEBGL_UNIFORM_TYPE.INT_VEC3:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform3i(location, value[0], value[1], value[2]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.BOOL_VEC4:
                  case WEBGL_UNIFORM_TYPE.INT_VEC4:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniform4i(location, value[0], value[1], value[2], value[3]);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT2:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniformMatrix2fv(location, false, value);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT3:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniformMatrix3fv(location, false, value);
                      };
                      break;
                  case WEBGL_UNIFORM_TYPE.FLOAT_MAT4:
                      this.upload = function () {
                          var value = this.value;
                          gl.uniformMatrix4fv(location, false, value);
                      };
                      break;
              }
          };
          return EgretWebGLUniform;
      }());
      wxgame.EgretWebGLUniform = EgretWebGLUniform;
      __reflect(EgretWebGLUniform.prototype, "egret.wxgame.EgretWebGLUniform");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));

(function (egret) {
  var wxgame;
  (function (wxgame) {
      /**
       * @private
       */
      var EgretShaderLib = (function () {
          function EgretShaderLib() {
          }
          EgretShaderLib.blur_frag = "precision mediump float;\nuniform vec2 blur;\nuniform sampler2D uSampler;\nvarying vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nvoid main()\n{\n    const int sampleRadius = 5;\n    const int samples = sampleRadius * 2 + 1;\n    vec2 blurUv = blur / uTextureSize;\n    vec4 color = vec4(0, 0, 0, 0);\n    vec2 uv = vec2(0.0, 0.0);\n    blurUv /= float(sampleRadius);\n    for (int i = -sampleRadius; i <= sampleRadius; i++) {\n        uv.x = vTextureCoord.x + float(i) * blurUv.x;\n        uv.y = vTextureCoord.y + float(i) * blurUv.y;\n        color += texture2D(uSampler, uv);\n    }\n    color /= float(samples);\n    gl_FragColor = color;\n}";
          EgretShaderLib.colorTransform_frag = "precision mediump float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nuniform mat4 matrix;\nuniform vec4 colorAdd;\nuniform sampler2D uSampler;\nvoid main(void) {\n    vec4 texColor = texture2D(uSampler, vTextureCoord);\n    if(texColor.a > 0.) {\n        texColor = vec4(texColor.rgb / texColor.a, texColor.a);\n    }\n    vec4 locColor = clamp(texColor * matrix + colorAdd, 0., 1.);\n    gl_FragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);\n}";
          EgretShaderLib.default_vert = "attribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = vec4(aColor.x, aColor.x, aColor.x, aColor.x);\n}";
          EgretShaderLib.glow_frag = "precision mediump float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float dist;\nuniform float angle;\nuniform vec4 color;\nuniform float alpha;\nuniform float blurX;\nuniform float blurY;\nuniform float strength;\nuniform float inner;\nuniform float knockout;\nuniform float hideObject;\nuniform vec2 uTextureSize;\nfloat random(vec3 scale, float seed)\n{\n    return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n}\nvoid main(void) {\n    vec2 px = vec2(1.0 / uTextureSize.x, 1.0 / uTextureSize.y);\n    const float linearSamplingTimes = 7.0;\n    const float circleSamplingTimes = 12.0;\n    vec4 ownColor = texture2D(uSampler, vTextureCoord);\n    vec4 curColor;\n    float totalAlpha = 0.0;\n    float maxTotalAlpha = 0.0;\n    float curDistanceX = 0.0;\n    float curDistanceY = 0.0;\n    float offsetX = dist * cos(angle) * px.x;\n    float offsetY = dist * sin(angle) * px.y;\n    const float PI = 3.14159265358979323846264;\n    float cosAngle;\n    float sinAngle;\n    float offset = PI * 2.0 / circleSamplingTimes * random(vec3(12.9898, 78.233, 151.7182), 0.0);\n    float stepX = blurX * px.x / linearSamplingTimes;\n    float stepY = blurY * px.y / linearSamplingTimes;\n    for (float a = 0.0; a <= PI * 2.0; a += PI * 2.0 / circleSamplingTimes) {\n        cosAngle = cos(a + offset);\n        sinAngle = sin(a + offset);\n        for (float i = 1.0; i <= linearSamplingTimes; i++) {\n            curDistanceX = i * stepX * cosAngle;\n            curDistanceY = i * stepY * sinAngle;\n            \n            curColor = texture2D(uSampler, vec2(vTextureCoord.x + curDistanceX - offsetX, vTextureCoord.y + curDistanceY + offsetY));\n            totalAlpha += (linearSamplingTimes - i) * curColor.a;\n            maxTotalAlpha += (linearSamplingTimes - i);\n        }\n    }\n    ownColor.a = max(ownColor.a, 0.0001);\n    ownColor.rgb = ownColor.rgb / ownColor.a;\n    float outerGlowAlpha = (totalAlpha / maxTotalAlpha) * strength * alpha * (1. - inner) * max(min(hideObject, knockout), 1. - ownColor.a);\n    float innerGlowAlpha = ((maxTotalAlpha - totalAlpha) / maxTotalAlpha) * strength * alpha * inner * ownColor.a;\n    ownColor.a = max(ownColor.a * knockout * (1. - hideObject), 0.0001);\n    vec3 mix1 = mix(ownColor.rgb, color.rgb, innerGlowAlpha / (innerGlowAlpha + ownColor.a));\n    vec3 mix2 = mix(mix1, color.rgb, outerGlowAlpha / (innerGlowAlpha + ownColor.a + outerGlowAlpha));\n    float resultAlpha = min(ownColor.a + outerGlowAlpha + innerGlowAlpha, 1.);\n    gl_FragColor = vec4(mix2 * resultAlpha, resultAlpha);\n}";
          EgretShaderLib.primitive_frag = "precision lowp float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvoid main(void) {\n    gl_FragColor = vColor;\n}";
          EgretShaderLib.texture_frag = "precision lowp float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nuniform sampler2D uSampler;\nvoid main(void) {\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor;\n}";
          return EgretShaderLib;
      }());
      wxgame.EgretShaderLib = EgretShaderLib;
      __reflect(EgretShaderLib.prototype, "egret.wxgame.EgretShaderLib");
  })(wxgame = egret.wxgame || (egret.wxgame = {}));
})(egret || (egret = {}));
;